Selaa lähdekoodia

Implement the extension GL_AMD_gpu_shader_half_float_fetch

- Support new opaque types: f16sampler*, f16image*, f16subpassInput*.
- Add new built-in GLSL texture/image functions.
Rex Xu 8 vuotta sitten
vanhempi
commit
1e5d7b0b27

+ 7 - 6
SPIRV/GLSL.ext.AMD.h

@@ -27,13 +27,8 @@
 #ifndef GLSLextAMD_H
 #define GLSLextAMD_H
 
-enum BuiltIn;
-enum Capability;
-enum Decoration;
-enum Op;
-
 static const int GLSLextAMDVersion = 100;
-static const int GLSLextAMDRevision = 6;
+static const int GLSLextAMDRevision = 7;
 
 // SPV_AMD_shader_ballot
 static const char* const E_SPV_AMD_shader_ballot = "SPV_AMD_shader_ballot";
@@ -107,4 +102,10 @@ static const char* const E_SPV_AMD_shader_image_load_store_lod = "SPV_AMD_shader
 // SPV_AMD_shader_fragment_mask
 static const char* const E_SPV_AMD_shader_fragment_mask = "SPV_AMD_shader_fragment_mask";
 
+// SPV_AMD_gpu_shader_half_float_fetch
+static const char* const E_SPV_AMD_gpu_shader_half_float_fetch = "SPV_AMD_gpu_shader_half_float_fetch";
+
+enum Capability;
+static const Capability CapabilityFloat16ImageAMD = static_cast<Capability>(5008);
+
 #endif  // #ifndef GLSLextAMD_H

+ 59 - 0
SPIRV/GlslangToSpv.cpp

@@ -2340,6 +2340,12 @@ spv::Id TGlslangToSpvTraverser::getSampledType(const glslang::TSampler& sampler)
 {
     switch (sampler.type) {
         case glslang::EbtFloat:    return builder.makeFloatType(32);
+#ifdef AMD_EXTENSIONS
+        case glslang::EbtFloat16:
+            builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch);
+            builder.addCapability(spv::CapabilityFloat16ImageAMD);
+            return builder.makeFloatType(16);
+#endif
         case glslang::EbtInt:      return builder.makeIntType(32);
         case glslang::EbtUint:     return builder.makeUintType(32);
         default:
@@ -3159,9 +3165,15 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
 
     glslang::TSampler sampler = {};
     bool cubeCompare = false;
+#ifdef AMD_EXTENSIONS
+    bool f16ShadowCompare = false;
+#endif
     if (node.isTexture() || node.isImage()) {
         sampler = glslangArguments[0]->getAsTyped()->getType().getSampler();
         cubeCompare = sampler.dim == glslang::EsdCube && sampler.arrayed && sampler.shadow;
+#ifdef AMD_EXTENSIONS
+        f16ShadowCompare = sampler.shadow && glslangArguments[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16;
+#endif
     }
 
     for (int i = 0; i < (int)glslangArguments.size(); ++i) {
@@ -3186,6 +3198,21 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
             if ((sampler.ms && i == 3) || (! sampler.ms && i == 2))
                 lvalue = true;
             break;
+#ifdef AMD_EXTENSIONS
+        case glslang::EOpSparseTexture:
+            if (((cubeCompare || f16ShadowCompare) && i == 3) || (! (cubeCompare || f16ShadowCompare) && i == 2))
+                lvalue = true;
+            break;
+        case glslang::EOpSparseTextureClamp:
+            if (((cubeCompare || f16ShadowCompare) && i == 4) || (! (cubeCompare || f16ShadowCompare) && i == 3))
+                lvalue = true;
+            break;
+        case glslang::EOpSparseTextureLod:
+        case glslang::EOpSparseTextureOffset:
+            if  ((f16ShadowCompare && i == 4) || (! f16ShadowCompare && i == 3))
+                lvalue = true;
+            break;
+#else
         case glslang::EOpSparseTexture:
             if ((cubeCompare && i == 3) || (! cubeCompare && i == 2))
                 lvalue = true;
@@ -3199,6 +3226,7 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
             if (i == 3)
                 lvalue = true;
             break;
+#endif
         case glslang::EOpSparseTextureFetch:
             if ((sampler.dim != glslang::EsdRect && i == 3) || (sampler.dim == glslang::EsdRect && i == 2))
                 lvalue = true;
@@ -3207,6 +3235,23 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
             if ((sampler.dim != glslang::EsdRect && i == 4) || (sampler.dim == glslang::EsdRect && i == 3))
                 lvalue = true;
             break;
+#ifdef AMD_EXTENSIONS
+        case glslang::EOpSparseTextureLodOffset:
+        case glslang::EOpSparseTextureGrad:
+        case glslang::EOpSparseTextureOffsetClamp:
+            if ((f16ShadowCompare && i == 5) || (! f16ShadowCompare && i == 4))
+                lvalue = true;
+            break;
+        case glslang::EOpSparseTextureGradOffset:
+        case glslang::EOpSparseTextureGradClamp:
+            if ((f16ShadowCompare && i == 6) || (! f16ShadowCompare && i == 5))
+                lvalue = true;
+            break;
+        case glslang::EOpSparseTextureGradOffsetClamp:
+            if ((f16ShadowCompare && i == 7) || (! f16ShadowCompare && i == 6))
+                lvalue = true;
+            break;
+#else
         case glslang::EOpSparseTextureLodOffset:
         case glslang::EOpSparseTextureGrad:
         case glslang::EOpSparseTextureOffsetClamp:
@@ -3222,6 +3267,7 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
             if (i == 6)
                 lvalue = true;
             break;
+#endif
         case glslang::EOpSparseTextureGather:
             if ((sampler.shadow && i == 3) || (! sampler.shadow && i == 2))
                 lvalue = true;
@@ -3274,6 +3320,12 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
     // Process a GLSL texturing op (will be SPV image)
     const glslang::TSampler sampler = node->getAsAggregate() ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler()
                                                              : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType().getSampler();
+#ifdef AMD_EXTENSIONS
+    bool f16ShadowCompare = (sampler.shadow && node->getAsAggregate())
+                                ? node->getAsAggregate()->getSequence()[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16
+                                : false;
+#endif
+
     std::vector<spv::Id> arguments;
     if (node->getAsAggregate())
         translateArguments(*node->getAsAggregate(), arguments);
@@ -3517,6 +3569,9 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
 #ifdef AMD_EXTENSIONS
         if (cracked.gather)
             ++nonBiasArgCount; // comp argument should be present when bias argument is present
+
+        if (f16ShadowCompare)
+            ++nonBiasArgCount;
 #endif
         if (cracked.offset)
             ++nonBiasArgCount;
@@ -3560,7 +3615,11 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
     bool noImplicitLod = false;
 
     // sort out where Dref is coming from
+#ifdef AMD_EXTENSIONS
+    if (cubeCompare || f16ShadowCompare) {
+#else
     if (cubeCompare) {
+#endif
         params.Dref = arguments[2];
         ++extraArgs;
     } else if (sampler.shadow && cracked.gather) {

+ 4 - 0
SPIRV/SpvBuilder.cpp

@@ -1751,7 +1751,11 @@ Id Builder::createTextureQueryCall(Op opCode, const TextureParameters& parameter
         break;
     }
     case OpImageQueryLod:
+#ifdef AMD_EXTENSIONS
+        resultType = makeVectorType(getScalarTypeId(getTypeId(parameters.coords)), 2);
+#else
         resultType = makeVectorType(makeFloatType(32), 2);
+#endif
         break;
     case OpImageQueryLevels:
     case OpImageQuerySamples:

+ 1 - 0
SPIRV/doc.cpp

@@ -849,6 +849,7 @@ const char* CapabilityString(int info)
     case 5013: return "StencilExportEXT";
 
 #ifdef AMD_EXTENSIONS
+    case 5008: return "Float16ImageAMD";
     case 5009: return "ImageGatherBiasLodAMD";
     case 5010: return "FragmentMaskAMD";
     case 5015: return "ImageReadWriteLodAMD";

+ 1 - 1
Test/baseResults/120.frag.out

@@ -52,7 +52,7 @@ ERROR: 0:209: 'assign' :  cannot convert from ' const float' to ' temp 4-compone
 ERROR: 0:212: 'sampler2DRect' : Reserved word. 
 ERROR: 0:244: ':' :  wrong operand types: no operation ':' exists that takes a left-hand operand of type ' global void' and a right operand of type ' const int' (or there is no acceptable conversion)
 ERROR: 0:245: ':' :  wrong operand types: no operation ':' exists that takes a left-hand operand of type ' const int' and a right operand of type ' global void' (or there is no acceptable conversion)
-ERROR: 0:248: 'shader half float' : required extension not requested: GL_AMD_gpu_shader_half_float
+ERROR: 0:248: 'half floating-point suffix' : required extension not requested: GL_AMD_gpu_shader_half_float
 ERROR: 0:248: 'half floating-point suffix' : not supported with this profile: none
 ERROR: 0:248: '' :  syntax error, unexpected IDENTIFIER, expecting COMMA or SEMICOLON
 ERROR: 56 compilation errors.  No code generated.

+ 7070 - 0
Test/baseResults/spv.float16Fetch.frag.out

@@ -0,0 +1,7070 @@
+spv.float16Fetch.frag
+// Module Version 10000
+// Generated by (magic number): 80004
+// Id's are bound by 5923
+
+                              Capability Shader
+                              Capability Float16
+                              Capability StorageImageMultisample
+                              Capability ImageCubeArray
+                              Capability ImageRect
+                              Capability SampledRect
+                              Capability InputAttachment
+                              Capability SparseResidency
+                              Capability MinLod
+                              Capability Sampled1D
+                              Capability Image1D
+                              Capability SampledCubeArray
+                              Capability SampledBuffer
+                              Capability ImageBuffer
+                              Capability ImageMSArray
+                              Capability ImageQuery
+                              Capability StorageInputOutput16
+                              Capability Float16ImageAMD
+                              Capability ImageGatherBiasLodAMD
+                              Extension  "SPV_AMD_gpu_shader_half_float"
+                              Extension  "SPV_AMD_gpu_shader_half_float_fetch"
+                              Extension  "SPV_AMD_texture_gather_bias_lod"
+                              Extension  "SPV_KHR_16bit_storage"
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 128 135 137 148 156 169 177 215 251 309 565 572 1393 1401 1409 1417 1425 1433 4257 4264 5913 5922
+                              ExecutionMode 4 OriginUpperLeft
+                              Source GLSL 450
+                              SourceExtension  "GL_AMD_gpu_shader_half_float"
+                              SourceExtension  "GL_AMD_gpu_shader_half_float_fetch"
+                              SourceExtension  "GL_AMD_texture_gather_bias_lod"
+                              SourceExtension  "GL_ARB_sparse_texture2"
+                              SourceExtension  "GL_ARB_sparse_texture_clamp"
+                              Name 4  "main"
+                              Name 9  "testTexture("
+                              Name 11  "testTextureProj("
+                              Name 13  "testTextureLod("
+                              Name 15  "testTextureOffset("
+                              Name 17  "testTextureProjOffset("
+                              Name 19  "testTextureLodOffset("
+                              Name 21  "testTextureProjLodOffset("
+                              Name 23  "testTexelFetch("
+                              Name 25  "testTexelFetchOffset("
+                              Name 27  "testTextureGrad("
+                              Name 29  "testTextureGradOffset("
+                              Name 31  "testTextureProjGrad("
+                              Name 33  "testTextureProjGradoffset("
+                              Name 35  "testTextureGather("
+                              Name 37  "testTextureGatherOffset("
+                              Name 39  "testTextureGatherOffsets("
+                              Name 41  "testTextureGatherLod("
+                              Name 43  "testTextureGatherLodOffset("
+                              Name 45  "testTextureGatherLodOffsets("
+                              Name 50  "testTextureSize("
+                              Name 55  "testTextureQueryLod("
+                              Name 58  "testTextureQueryLevels("
+                              Name 60  "testTextureSamples("
+                              Name 62  "testImageLoad("
+                              Name 67  "testImageStore(vf164;"
+                              Name 66  "data"
+                              Name 69  "testSparseTexture("
+                              Name 71  "testSparseTextureLod("
+                              Name 73  "testSparseTextureOffset("
+                              Name 75  "testSparseTextureLodOffset("
+                              Name 77  "testSparseTextureGrad("
+                              Name 79  "testSparseTextureGradOffset("
+                              Name 81  "testSparseTexelFetch("
+                              Name 83  "testSparseTexelFetchOffset("
+                              Name 85  "testSparseTextureGather("
+                              Name 87  "testSparseTextureGatherOffset("
+                              Name 89  "testSparseTextureGatherOffsets("
+                              Name 91  "testSparseTextureGatherLod("
+                              Name 93  "testSparseTextureGatherLodOffset("
+                              Name 95  "testSparseTextureGatherLodOffsets("
+                              Name 97  "testSparseImageLoad("
+                              Name 99  "testSparseTextureClamp("
+                              Name 101  "testTextureClamp("
+                              Name 103  "testSparseTextureOffsetClamp("
+                              Name 105  "testTextureOffsetClamp("
+                              Name 107  "testSparseTextureGradClamp("
+                              Name 109  "testTextureGradClamp("
+                              Name 111  "testSparseTextureGradOffsetClamp("
+                              Name 113  "testTextureGradOffsetClamp("
+                              Name 115  "testCombinedTextureSampler("
+                              Name 117  "testSubpassLoad("
+                              Name 119  "texel"
+                              Name 125  "s1D"
+                              Name 128  "c1"
+                              Name 135  "f16c1"
+                              Name 137  "f16bias"
+                              Name 145  "s2D"
+                              Name 148  "c2"
+                              Name 156  "f16c2"
+                              Name 165  "s3D"
+                              Name 169  "c3"
+                              Name 177  "f16c3"
+                              Name 186  "sCube"
+                              Name 201  "s1DShadow"
+                              Name 215  "compare"
+                              Name 226  "s2DShadow"
+                              Name 247  "sCubeShadow"
+                              Name 251  "c4"
+                              Name 271  "s1DArray"
+                              Name 286  "s2DArray"
+                              Name 301  "sCubeArray"
+                              Name 309  "f16c4"
+                              Name 318  "s1DArrayShadow"
+                              Name 339  "s2DArrayShadow"
+                              Name 359  "s2DRect"
+                              Name 373  "s2DRectShadow"
+                              Name 393  "sCubeArrayShadow"
+                              Name 413  "texel"
+                              Name 562  "texel"
+                              Name 565  "lod"
+                              Name 572  "f16lod"
+                              Name 706  "texel"
+                              Name 863  "texel"
+                              Name 1012  "texel"
+                              Name 1130  "texel"
+                              Name 1244  "texel"
+                              Name 1300  "sBuffer"
+                              Name 1311  "s2DMS"
+                              Name 1322  "s2DMSArray"
+                              Name 1334  "texel"
+                              Name 1390  "texel"
+                              Name 1393  "dPdxy1"
+                              Name 1401  "f16dPdxy1"
+                              Name 1409  "dPdxy2"
+                              Name 1417  "f16dPdxy2"
+                              Name 1425  "dPdxy3"
+                              Name 1433  "f16dPdxy3"
+                              Name 1632  "texel"
+                              Name 1820  "texel"
+                              Name 2002  "texel"
+                              Name 2184  "texel"
+                              Name 2303  "texel"
+                              Name 2375  "texel"
+                              Name 2450  "texel"
+                              Name 2502  "texel"
+                              Name 2530  "texel"
+                              Name 2559  "size"
+                              Name 2733  "lod"
+                              Name 2869  "levels"
+                              Name 2938  "samples"
+                              Name 2952  "texel"
+                              Name 2955  "i1D"
+                              Name 2964  "i2D"
+                              Name 2973  "i3D"
+                              Name 2982  "i2DRect"
+                              Name 2991  "iCube"
+                              Name 3000  "iBuffer"
+                              Name 3009  "i1DArray"
+                              Name 3018  "i2DArray"
+                              Name 3027  "iCubeArray"
+                              Name 3036  "i2DMS"
+                              Name 3045  "i2DMSArray"
+                              Name 3099  "texel"
+                              Name 3102  "ResType"
+                              Name 3138  "ResType"
+                              Name 3242  "texel"
+                              Name 3322  "texel"
+                              Name 3412  "texel"
+                              Name 3468  "texel"
+                              Name 3628  "texel"
+                              Name 3742  "texel"
+                              Name 3794  "texel"
+                              Name 3832  "texel"
+                              Name 3950  "texel"
+                              Name 4022  "texel"
+                              Name 4094  "texel"
+                              Name 4146  "texel"
+                              Name 4174  "texel"
+                              Name 4202  "texel"
+                              Name 4254  "texel"
+                              Name 4257  "lodClamp"
+                              Name 4264  "f16lodClamp"
+                              Name 4391  "texel"
+                              Name 4598  "texel"
+                              Name 4674  "texel"
+                              Name 4818  "texel"
+                              Name 4962  "texel"
+                              Name 5188  "texel"
+                              Name 5280  "texel"
+                              Name 5452  "texel"
+                              Name 5454  "t1D"
+                              Name 5458  "s"
+                              Name 5474  "t2D"
+                              Name 5491  "t3D"
+                              Name 5508  "tCube"
+                              Name 5525  "sShadow"
+                              Name 5589  "t1DArray"
+                              Name 5606  "t2DArray"
+                              Name 5623  "tCubeArray"
+                              Name 5681  "t2DRect"
+                              Name 5741  "subpass"
+                              Name 5747  "subpassMS"
+                              Name 5753  "result"
+                              Name 5834  "param"
+                              Name 5913  "fragColor"
+                              Name 5917  "tBuffer"
+                              Name 5919  "t2DMS"
+                              Name 5921  "t2DMSArray"
+                              Name 5922  "bias"
+                              Decorate 125(s1D) DescriptorSet 0
+                              Decorate 125(s1D) Binding 0
+                              Decorate 128(c1) Location 0
+                              Decorate 135(f16c1) Location 11
+                              Decorate 137(f16bias) Location 16
+                              Decorate 145(s2D) DescriptorSet 0
+                              Decorate 145(s2D) Binding 1
+                              Decorate 148(c2) Location 1
+                              Decorate 156(f16c2) Location 12
+                              Decorate 165(s3D) DescriptorSet 0
+                              Decorate 165(s3D) Binding 2
+                              Decorate 169(c3) Location 2
+                              Decorate 177(f16c3) Location 13
+                              Decorate 186(sCube) DescriptorSet 0
+                              Decorate 186(sCube) Binding 4
+                              Decorate 201(s1DShadow) DescriptorSet 0
+                              Decorate 201(s1DShadow) Binding 11
+                              Decorate 215(compare) Location 4
+                              Decorate 226(s2DShadow) DescriptorSet 0
+                              Decorate 226(s2DShadow) Binding 12
+                              Decorate 247(sCubeShadow) DescriptorSet 0
+                              Decorate 247(sCubeShadow) Binding 14
+                              Decorate 251(c4) Location 3
+                              Decorate 271(s1DArray) DescriptorSet 0
+                              Decorate 271(s1DArray) Binding 7
+                              Decorate 286(s2DArray) DescriptorSet 0
+                              Decorate 286(s2DArray) Binding 8
+                              Decorate 301(sCubeArray) DescriptorSet 0
+                              Decorate 301(sCubeArray) Binding 9
+                              Decorate 309(f16c4) Location 14
+                              Decorate 318(s1DArrayShadow) DescriptorSet 0
+                              Decorate 318(s1DArrayShadow) Binding 15
+                              Decorate 339(s2DArrayShadow) DescriptorSet 0
+                              Decorate 339(s2DArrayShadow) Binding 16
+                              Decorate 359(s2DRect) DescriptorSet 0
+                              Decorate 359(s2DRect) Binding 3
+                              Decorate 373(s2DRectShadow) DescriptorSet 0
+                              Decorate 373(s2DRectShadow) Binding 13
+                              Decorate 393(sCubeArrayShadow) DescriptorSet 0
+                              Decorate 393(sCubeArrayShadow) Binding 17
+                              Decorate 565(lod) Location 5
+                              Decorate 572(f16lod) Location 15
+                              Decorate 1300(sBuffer) DescriptorSet 0
+                              Decorate 1300(sBuffer) Binding 5
+                              Decorate 1311(s2DMS) DescriptorSet 0
+                              Decorate 1311(s2DMS) Binding 6
+                              Decorate 1322(s2DMSArray) DescriptorSet 0
+                              Decorate 1322(s2DMSArray) Binding 10
+                              Decorate 1393(dPdxy1) Location 8
+                              Decorate 1401(f16dPdxy1) Location 18
+                              Decorate 1409(dPdxy2) Location 9
+                              Decorate 1417(f16dPdxy2) Location 19
+                              Decorate 1425(dPdxy3) Location 10
+                              Decorate 1433(f16dPdxy3) Location 20
+                              Decorate 2955(i1D) DescriptorSet 1
+                              Decorate 2955(i1D) Binding 0
+                              Decorate 2964(i2D) DescriptorSet 1
+                              Decorate 2964(i2D) Binding 1
+                              Decorate 2973(i3D) DescriptorSet 1
+                              Decorate 2973(i3D) Binding 2
+                              Decorate 2982(i2DRect) DescriptorSet 1
+                              Decorate 2982(i2DRect) Binding 3
+                              Decorate 2991(iCube) DescriptorSet 1
+                              Decorate 2991(iCube) Binding 4
+                              Decorate 3000(iBuffer) DescriptorSet 1
+                              Decorate 3000(iBuffer) Binding 8
+                              Decorate 3009(i1DArray) DescriptorSet 1
+                              Decorate 3009(i1DArray) Binding 5
+                              Decorate 3018(i2DArray) DescriptorSet 1
+                              Decorate 3018(i2DArray) Binding 6
+                              Decorate 3027(iCubeArray) DescriptorSet 1
+                              Decorate 3027(iCubeArray) Binding 7
+                              Decorate 3036(i2DMS) DescriptorSet 1
+                              Decorate 3036(i2DMS) Binding 9
+                              Decorate 3045(i2DMSArray) DescriptorSet 1
+                              Decorate 3045(i2DMSArray) Binding 10
+                              Decorate 4257(lodClamp) Location 7
+                              Decorate 4264(f16lodClamp) Location 17
+                              Decorate 5454(t1D) DescriptorSet 2
+                              Decorate 5454(t1D) Binding 0
+                              Decorate 5458(s) DescriptorSet 2
+                              Decorate 5458(s) Binding 11
+                              Decorate 5474(t2D) DescriptorSet 2
+                              Decorate 5474(t2D) Binding 1
+                              Decorate 5491(t3D) DescriptorSet 2
+                              Decorate 5491(t3D) Binding 2
+                              Decorate 5508(tCube) DescriptorSet 2
+                              Decorate 5508(tCube) Binding 4
+                              Decorate 5525(sShadow) DescriptorSet 2
+                              Decorate 5525(sShadow) Binding 12
+                              Decorate 5589(t1DArray) DescriptorSet 2
+                              Decorate 5589(t1DArray) Binding 5
+                              Decorate 5606(t2DArray) DescriptorSet 2
+                              Decorate 5606(t2DArray) Binding 6
+                              Decorate 5623(tCubeArray) DescriptorSet 2
+                              Decorate 5623(tCubeArray) Binding 7
+                              Decorate 5681(t2DRect) DescriptorSet 2
+                              Decorate 5681(t2DRect) Binding 3
+                              Decorate 5741(subpass) DescriptorSet 3
+                              Decorate 5741(subpass) Binding 0
+                              Decorate 5741(subpass) InputAttachmentIndex 0
+                              Decorate 5747(subpassMS) DescriptorSet 3
+                              Decorate 5747(subpassMS) Binding 1
+                              Decorate 5747(subpassMS) InputAttachmentIndex 0
+                              Decorate 5913(fragColor) Location 0
+                              Decorate 5917(tBuffer) DescriptorSet 2
+                              Decorate 5917(tBuffer) Binding 8
+                              Decorate 5919(t2DMS) DescriptorSet 2
+                              Decorate 5919(t2DMS) Binding 9
+                              Decorate 5921(t2DMSArray) DescriptorSet 2
+                              Decorate 5921(t2DMSArray) Binding 10
+                              Decorate 5922(bias) Location 6
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeFloat 16
+               7:             TypeVector 6(float) 4
+               8:             TypeFunction 7(fvec4)
+              47:             TypeInt 32 1
+              48:             TypeVector 47(int) 4
+              49:             TypeFunction 48(ivec4)
+              52:             TypeFloat 32
+              53:             TypeVector 52(float) 2
+              54:             TypeFunction 53(fvec2)
+              57:             TypeFunction 47(int)
+              64:             TypePointer Function 7(fvec4)
+              65:             TypeFunction 2 64(ptr)
+             120:    6(float) Constant 0
+             121:    7(fvec4) ConstantComposite 120 120 120 120
+             122:             TypeImage 6(float) 1D sampled format:Unknown
+             123:             TypeSampledImage 122
+             124:             TypePointer UniformConstant 123
+        125(s1D):    124(ptr) Variable UniformConstant
+             127:             TypePointer Input 52(float)
+         128(c1):    127(ptr) Variable Input
+             134:             TypePointer Input 6(float)
+      135(f16c1):    134(ptr) Variable Input
+    137(f16bias):    134(ptr) Variable Input
+             142:             TypeImage 6(float) 2D sampled format:Unknown
+             143:             TypeSampledImage 142
+             144:             TypePointer UniformConstant 143
+        145(s2D):    144(ptr) Variable UniformConstant
+             147:             TypePointer Input 53(fvec2)
+         148(c2):    147(ptr) Variable Input
+             154:             TypeVector 6(float) 2
+             155:             TypePointer Input 154(fvec2)
+      156(f16c2):    155(ptr) Variable Input
+             162:             TypeImage 6(float) 3D sampled format:Unknown
+             163:             TypeSampledImage 162
+             164:             TypePointer UniformConstant 163
+        165(s3D):    164(ptr) Variable UniformConstant
+             167:             TypeVector 52(float) 3
+             168:             TypePointer Input 167(fvec3)
+         169(c3):    168(ptr) Variable Input
+             175:             TypeVector 6(float) 3
+             176:             TypePointer Input 175(fvec3)
+      177(f16c3):    176(ptr) Variable Input
+             183:             TypeImage 6(float) Cube sampled format:Unknown
+             184:             TypeSampledImage 183
+             185:             TypePointer UniformConstant 184
+      186(sCube):    185(ptr) Variable UniformConstant
+             198:             TypeImage 6(float) 1D depth sampled format:Unknown
+             199:             TypeSampledImage 198
+             200:             TypePointer UniformConstant 199
+  201(s1DShadow):    200(ptr) Variable UniformConstant
+             206:             TypeInt 32 0
+             207:    206(int) Constant 0
+             208:             TypePointer Function 6(float)
+    215(compare):    127(ptr) Variable Input
+             223:             TypeImage 6(float) 2D depth sampled format:Unknown
+             224:             TypeSampledImage 223
+             225:             TypePointer UniformConstant 224
+  226(s2DShadow):    225(ptr) Variable UniformConstant
+             244:             TypeImage 6(float) Cube depth sampled format:Unknown
+             245:             TypeSampledImage 244
+             246:             TypePointer UniformConstant 245
+247(sCubeShadow):    246(ptr) Variable UniformConstant
+             249:             TypeVector 52(float) 4
+             250:             TypePointer Input 249(fvec4)
+         251(c4):    250(ptr) Variable Input
+             268:             TypeImage 6(float) 1D array sampled format:Unknown
+             269:             TypeSampledImage 268
+             270:             TypePointer UniformConstant 269
+   271(s1DArray):    270(ptr) Variable UniformConstant
+             283:             TypeImage 6(float) 2D array sampled format:Unknown
+             284:             TypeSampledImage 283
+             285:             TypePointer UniformConstant 284
+   286(s2DArray):    285(ptr) Variable UniformConstant
+             298:             TypeImage 6(float) Cube array sampled format:Unknown
+             299:             TypeSampledImage 298
+             300:             TypePointer UniformConstant 299
+ 301(sCubeArray):    300(ptr) Variable UniformConstant
+             308:             TypePointer Input 7(fvec4)
+      309(f16c4):    308(ptr) Variable Input
+             315:             TypeImage 6(float) 1D depth array sampled format:Unknown
+             316:             TypeSampledImage 315
+             317:             TypePointer UniformConstant 316
+318(s1DArrayShadow):    317(ptr) Variable UniformConstant
+             336:             TypeImage 6(float) 2D depth array sampled format:Unknown
+             337:             TypeSampledImage 336
+             338:             TypePointer UniformConstant 337
+339(s2DArrayShadow):    338(ptr) Variable UniformConstant
+             356:             TypeImage 6(float) Rect sampled format:Unknown
+             357:             TypeSampledImage 356
+             358:             TypePointer UniformConstant 357
+    359(s2DRect):    358(ptr) Variable UniformConstant
+             370:             TypeImage 6(float) Rect depth sampled format:Unknown
+             371:             TypeSampledImage 370
+             372:             TypePointer UniformConstant 371
+373(s2DRectShadow):    372(ptr) Variable UniformConstant
+             390:             TypeImage 6(float) Cube depth array sampled format:Unknown
+             391:             TypeSampledImage 390
+             392:             TypePointer UniformConstant 391
+393(sCubeArrayShadow):    392(ptr) Variable UniformConstant
+        565(lod):    127(ptr) Variable Input
+     572(f16lod):    134(ptr) Variable Input
+             709:     47(int) Constant 1
+             721:             TypeVector 47(int) 2
+             722:  721(ivec2) ConstantComposite 709 709
+             734:             TypeVector 47(int) 3
+             735:  734(ivec3) ConstantComposite 709 709 709
+            1297:             TypeImage 6(float) Buffer sampled format:Unknown
+            1298:             TypeSampledImage 1297
+            1299:             TypePointer UniformConstant 1298
+   1300(sBuffer):   1299(ptr) Variable UniformConstant
+            1308:             TypeImage 6(float) 2D multi-sampled sampled format:Unknown
+            1309:             TypeSampledImage 1308
+            1310:             TypePointer UniformConstant 1309
+     1311(s2DMS):   1310(ptr) Variable UniformConstant
+            1319:             TypeImage 6(float) 2D array multi-sampled sampled format:Unknown
+            1320:             TypeSampledImage 1319
+            1321:             TypePointer UniformConstant 1320
+1322(s2DMSArray):   1321(ptr) Variable UniformConstant
+            1326:     47(int) Constant 2
+    1393(dPdxy1):    127(ptr) Variable Input
+ 1401(f16dPdxy1):    134(ptr) Variable Input
+    1409(dPdxy2):    147(ptr) Variable Input
+ 1417(f16dPdxy2):    155(ptr) Variable Input
+    1425(dPdxy3):    168(ptr) Variable Input
+ 1433(f16dPdxy3):    176(ptr) Variable Input
+            2187:     47(int) Constant 0
+            2378:    206(int) Constant 4
+            2379:             TypeArray 721(ivec2) 2378
+            2380:        2379 ConstantComposite 722 722 722 722
+            2558:             TypePointer Function 48(ivec4)
+            2560:   48(ivec4) ConstantComposite 2187 2187 2187 2187
+            2566:             TypePointer Function 47(int)
+            2732:             TypePointer Function 53(fvec2)
+            2734:   52(float) Constant 0
+            2735:   53(fvec2) ConstantComposite 2734 2734
+            2953:             TypeImage 6(float) 1D nonsampled format:Rgba16f
+            2954:             TypePointer UniformConstant 2953
+       2955(i1D):   2954(ptr) Variable UniformConstant
+            2962:             TypeImage 6(float) 2D nonsampled format:Rgba16f
+            2963:             TypePointer UniformConstant 2962
+       2964(i2D):   2963(ptr) Variable UniformConstant
+            2971:             TypeImage 6(float) 3D nonsampled format:Rgba16f
+            2972:             TypePointer UniformConstant 2971
+       2973(i3D):   2972(ptr) Variable UniformConstant
+            2980:             TypeImage 6(float) Rect nonsampled format:Rgba16f
+            2981:             TypePointer UniformConstant 2980
+   2982(i2DRect):   2981(ptr) Variable UniformConstant
+            2989:             TypeImage 6(float) Cube nonsampled format:Rgba16f
+            2990:             TypePointer UniformConstant 2989
+     2991(iCube):   2990(ptr) Variable UniformConstant
+            2998:             TypeImage 6(float) Buffer nonsampled format:Rgba16f
+            2999:             TypePointer UniformConstant 2998
+   3000(iBuffer):   2999(ptr) Variable UniformConstant
+            3007:             TypeImage 6(float) 1D array nonsampled format:Rgba16f
+            3008:             TypePointer UniformConstant 3007
+  3009(i1DArray):   3008(ptr) Variable UniformConstant
+            3016:             TypeImage 6(float) 2D array nonsampled format:Rgba16f
+            3017:             TypePointer UniformConstant 3016
+  3018(i2DArray):   3017(ptr) Variable UniformConstant
+            3025:             TypeImage 6(float) Cube array nonsampled format:Rgba16f
+            3026:             TypePointer UniformConstant 3025
+3027(iCubeArray):   3026(ptr) Variable UniformConstant
+            3034:             TypeImage 6(float) 2D multi-sampled nonsampled format:Rgba16f
+            3035:             TypePointer UniformConstant 3034
+     3036(i2DMS):   3035(ptr) Variable UniformConstant
+            3043:             TypeImage 6(float) 2D array multi-sampled nonsampled format:Rgba16f
+            3044:             TypePointer UniformConstant 3043
+3045(i2DMSArray):   3044(ptr) Variable UniformConstant
+   3102(ResType):             TypeStruct 47(int) 7(fvec4)
+   3138(ResType):             TypeStruct 47(int) 6(float)
+  4257(lodClamp):    127(ptr) Variable Input
+4264(f16lodClamp):    134(ptr) Variable Input
+            5453:             TypePointer UniformConstant 122
+       5454(t1D):   5453(ptr) Variable UniformConstant
+            5456:             TypeSampler
+            5457:             TypePointer UniformConstant 5456
+         5458(s):   5457(ptr) Variable UniformConstant
+            5473:             TypePointer UniformConstant 142
+       5474(t2D):   5473(ptr) Variable UniformConstant
+            5490:             TypePointer UniformConstant 162
+       5491(t3D):   5490(ptr) Variable UniformConstant
+            5507:             TypePointer UniformConstant 183
+     5508(tCube):   5507(ptr) Variable UniformConstant
+   5525(sShadow):   5457(ptr) Variable UniformConstant
+            5588:             TypePointer UniformConstant 268
+  5589(t1DArray):   5588(ptr) Variable UniformConstant
+            5605:             TypePointer UniformConstant 283
+  5606(t2DArray):   5605(ptr) Variable UniformConstant
+            5622:             TypePointer UniformConstant 298
+5623(tCubeArray):   5622(ptr) Variable UniformConstant
+            5680:             TypePointer UniformConstant 356
+   5681(t2DRect):   5680(ptr) Variable UniformConstant
+            5739:             TypeImage 6(float) SubpassData nonsampled format:Unknown
+            5740:             TypePointer UniformConstant 5739
+   5741(subpass):   5740(ptr) Variable UniformConstant
+            5743:  721(ivec2) ConstantComposite 2187 2187
+            5745:             TypeImage 6(float) SubpassData multi-sampled nonsampled format:Unknown
+            5746:             TypePointer UniformConstant 5745
+ 5747(subpassMS):   5746(ptr) Variable UniformConstant
+            5912:             TypePointer Output 249(fvec4)
+ 5913(fragColor):   5912(ptr) Variable Output
+            5916:             TypePointer UniformConstant 1297
+   5917(tBuffer):   5916(ptr) Variable UniformConstant
+            5918:             TypePointer UniformConstant 1308
+     5919(t2DMS):   5918(ptr) Variable UniformConstant
+            5920:             TypePointer UniformConstant 1319
+5921(t2DMSArray):   5920(ptr) Variable UniformConstant
+      5922(bias):    127(ptr) Variable Input
+         4(main):           2 Function None 3
+               5:             Label
+    5753(result):     64(ptr) Variable Function
+     5834(param):     64(ptr) Variable Function
+                              Store 5753(result) 121
+            5754:    7(fvec4) FunctionCall 9(testTexture()
+            5755:    7(fvec4) Load 5753(result)
+            5756:    7(fvec4) FAdd 5755 5754
+                              Store 5753(result) 5756
+            5757:    7(fvec4) FunctionCall 11(testTextureProj()
+            5758:    7(fvec4) Load 5753(result)
+            5759:    7(fvec4) FAdd 5758 5757
+                              Store 5753(result) 5759
+            5760:    7(fvec4) FunctionCall 13(testTextureLod()
+            5761:    7(fvec4) Load 5753(result)
+            5762:    7(fvec4) FAdd 5761 5760
+                              Store 5753(result) 5762
+            5763:    7(fvec4) FunctionCall 15(testTextureOffset()
+            5764:    7(fvec4) Load 5753(result)
+            5765:    7(fvec4) FAdd 5764 5763
+                              Store 5753(result) 5765
+            5766:    7(fvec4) FunctionCall 19(testTextureLodOffset()
+            5767:    7(fvec4) Load 5753(result)
+            5768:    7(fvec4) FAdd 5767 5766
+                              Store 5753(result) 5768
+            5769:    7(fvec4) FunctionCall 21(testTextureProjLodOffset()
+            5770:    7(fvec4) Load 5753(result)
+            5771:    7(fvec4) FAdd 5770 5769
+                              Store 5753(result) 5771
+            5772:    7(fvec4) FunctionCall 23(testTexelFetch()
+            5773:    7(fvec4) Load 5753(result)
+            5774:    7(fvec4) FAdd 5773 5772
+                              Store 5753(result) 5774
+            5775:    7(fvec4) FunctionCall 25(testTexelFetchOffset()
+            5776:    7(fvec4) Load 5753(result)
+            5777:    7(fvec4) FAdd 5776 5775
+                              Store 5753(result) 5777
+            5778:    7(fvec4) FunctionCall 27(testTextureGrad()
+            5779:    7(fvec4) Load 5753(result)
+            5780:    7(fvec4) FAdd 5779 5778
+                              Store 5753(result) 5780
+            5781:    7(fvec4) FunctionCall 29(testTextureGradOffset()
+            5782:    7(fvec4) Load 5753(result)
+            5783:    7(fvec4) FAdd 5782 5781
+                              Store 5753(result) 5783
+            5784:    7(fvec4) FunctionCall 31(testTextureProjGrad()
+            5785:    7(fvec4) Load 5753(result)
+            5786:    7(fvec4) FAdd 5785 5784
+                              Store 5753(result) 5786
+            5787:    7(fvec4) FunctionCall 33(testTextureProjGradoffset()
+            5788:    7(fvec4) Load 5753(result)
+            5789:    7(fvec4) FAdd 5788 5787
+                              Store 5753(result) 5789
+            5790:    7(fvec4) FunctionCall 35(testTextureGather()
+            5791:    7(fvec4) Load 5753(result)
+            5792:    7(fvec4) FAdd 5791 5790
+                              Store 5753(result) 5792
+            5793:    7(fvec4) FunctionCall 37(testTextureGatherOffset()
+            5794:    7(fvec4) Load 5753(result)
+            5795:    7(fvec4) FAdd 5794 5793
+                              Store 5753(result) 5795
+            5796:    7(fvec4) FunctionCall 39(testTextureGatherOffsets()
+            5797:    7(fvec4) Load 5753(result)
+            5798:    7(fvec4) FAdd 5797 5796
+                              Store 5753(result) 5798
+            5799:    7(fvec4) FunctionCall 41(testTextureGatherLod()
+            5800:    7(fvec4) Load 5753(result)
+            5801:    7(fvec4) FAdd 5800 5799
+                              Store 5753(result) 5801
+            5802:    7(fvec4) FunctionCall 43(testTextureGatherLodOffset()
+            5803:    7(fvec4) Load 5753(result)
+            5804:    7(fvec4) FAdd 5803 5802
+                              Store 5753(result) 5804
+            5805:    7(fvec4) FunctionCall 45(testTextureGatherLodOffsets()
+            5806:    7(fvec4) Load 5753(result)
+            5807:    7(fvec4) FAdd 5806 5805
+                              Store 5753(result) 5807
+            5808:   48(ivec4) FunctionCall 50(testTextureSize()
+            5809:    7(fvec4) ConvertSToF 5808
+            5810:    7(fvec4) Load 5753(result)
+            5811:    7(fvec4) FAdd 5810 5809
+                              Store 5753(result) 5811
+            5812:   53(fvec2) FunctionCall 55(testTextureQueryLod()
+            5813:  154(fvec2) FConvert 5812
+            5814:    7(fvec4) Load 5753(result)
+            5815:  154(fvec2) VectorShuffle 5814 5814 0 1
+            5816:  154(fvec2) FAdd 5815 5813
+            5817:    7(fvec4) Load 5753(result)
+            5818:    7(fvec4) VectorShuffle 5817 5816 4 5 2 3
+                              Store 5753(result) 5818
+            5819:     47(int) FunctionCall 58(testTextureQueryLevels()
+            5820:    6(float) ConvertSToF 5819
+            5821:    208(ptr) AccessChain 5753(result) 207
+            5822:    6(float) Load 5821
+            5823:    6(float) FAdd 5822 5820
+            5824:    208(ptr) AccessChain 5753(result) 207
+                              Store 5824 5823
+            5825:     47(int) FunctionCall 60(testTextureSamples()
+            5826:    6(float) ConvertSToF 5825
+            5827:    208(ptr) AccessChain 5753(result) 207
+            5828:    6(float) Load 5827
+            5829:    6(float) FAdd 5828 5826
+            5830:    208(ptr) AccessChain 5753(result) 207
+                              Store 5830 5829
+            5831:    7(fvec4) FunctionCall 62(testImageLoad()
+            5832:    7(fvec4) Load 5753(result)
+            5833:    7(fvec4) FAdd 5832 5831
+                              Store 5753(result) 5833
+            5835:    7(fvec4) Load 5753(result)
+                              Store 5834(param) 5835
+            5836:           2 FunctionCall 67(testImageStore(vf164;) 5834(param)
+            5837:    7(fvec4) FunctionCall 69(testSparseTexture()
+            5838:    7(fvec4) Load 5753(result)
+            5839:    7(fvec4) FAdd 5838 5837
+                              Store 5753(result) 5839
+            5840:    7(fvec4) FunctionCall 71(testSparseTextureLod()
+            5841:    7(fvec4) Load 5753(result)
+            5842:    7(fvec4) FAdd 5841 5840
+                              Store 5753(result) 5842
+            5843:    7(fvec4) FunctionCall 73(testSparseTextureOffset()
+            5844:    7(fvec4) Load 5753(result)
+            5845:    7(fvec4) FAdd 5844 5843
+                              Store 5753(result) 5845
+            5846:    7(fvec4) FunctionCall 75(testSparseTextureLodOffset()
+            5847:    7(fvec4) Load 5753(result)
+            5848:    7(fvec4) FAdd 5847 5846
+                              Store 5753(result) 5848
+            5849:    7(fvec4) FunctionCall 77(testSparseTextureGrad()
+            5850:    7(fvec4) Load 5753(result)
+            5851:    7(fvec4) FAdd 5850 5849
+                              Store 5753(result) 5851
+            5852:    7(fvec4) FunctionCall 79(testSparseTextureGradOffset()
+            5853:    7(fvec4) Load 5753(result)
+            5854:    7(fvec4) FAdd 5853 5852
+                              Store 5753(result) 5854
+            5855:    7(fvec4) FunctionCall 81(testSparseTexelFetch()
+            5856:    7(fvec4) Load 5753(result)
+            5857:    7(fvec4) FAdd 5856 5855
+                              Store 5753(result) 5857
+            5858:    7(fvec4) FunctionCall 83(testSparseTexelFetchOffset()
+            5859:    7(fvec4) Load 5753(result)
+            5860:    7(fvec4) FAdd 5859 5858
+                              Store 5753(result) 5860
+            5861:    7(fvec4) FunctionCall 85(testSparseTextureGather()
+            5862:    7(fvec4) Load 5753(result)
+            5863:    7(fvec4) FAdd 5862 5861
+                              Store 5753(result) 5863
+            5864:    7(fvec4) FunctionCall 87(testSparseTextureGatherOffset()
+            5865:    7(fvec4) Load 5753(result)
+            5866:    7(fvec4) FAdd 5865 5864
+                              Store 5753(result) 5866
+            5867:    7(fvec4) FunctionCall 89(testSparseTextureGatherOffsets()
+            5868:    7(fvec4) Load 5753(result)
+            5869:    7(fvec4) FAdd 5868 5867
+                              Store 5753(result) 5869
+            5870:    7(fvec4) FunctionCall 91(testSparseTextureGatherLod()
+            5871:    7(fvec4) Load 5753(result)
+            5872:    7(fvec4) FAdd 5871 5870
+                              Store 5753(result) 5872
+            5873:    7(fvec4) FunctionCall 93(testSparseTextureGatherLodOffset()
+            5874:    7(fvec4) Load 5753(result)
+            5875:    7(fvec4) FAdd 5874 5873
+                              Store 5753(result) 5875
+            5876:    7(fvec4) FunctionCall 95(testSparseTextureGatherLodOffsets()
+            5877:    7(fvec4) Load 5753(result)
+            5878:    7(fvec4) FAdd 5877 5876
+                              Store 5753(result) 5878
+            5879:    7(fvec4) FunctionCall 97(testSparseImageLoad()
+            5880:    7(fvec4) Load 5753(result)
+            5881:    7(fvec4) FAdd 5880 5879
+                              Store 5753(result) 5881
+            5882:    7(fvec4) FunctionCall 99(testSparseTextureClamp()
+            5883:    7(fvec4) Load 5753(result)
+            5884:    7(fvec4) FAdd 5883 5882
+                              Store 5753(result) 5884
+            5885:    7(fvec4) FunctionCall 101(testTextureClamp()
+            5886:    7(fvec4) Load 5753(result)
+            5887:    7(fvec4) FAdd 5886 5885
+                              Store 5753(result) 5887
+            5888:    7(fvec4) FunctionCall 103(testSparseTextureOffsetClamp()
+            5889:    7(fvec4) Load 5753(result)
+            5890:    7(fvec4) FAdd 5889 5888
+                              Store 5753(result) 5890
+            5891:    7(fvec4) FunctionCall 105(testTextureOffsetClamp()
+            5892:    7(fvec4) Load 5753(result)
+            5893:    7(fvec4) FAdd 5892 5891
+                              Store 5753(result) 5893
+            5894:    7(fvec4) FunctionCall 77(testSparseTextureGrad()
+            5895:    7(fvec4) Load 5753(result)
+            5896:    7(fvec4) FAdd 5895 5894
+                              Store 5753(result) 5896
+            5897:    7(fvec4) FunctionCall 27(testTextureGrad()
+            5898:    7(fvec4) Load 5753(result)
+            5899:    7(fvec4) FAdd 5898 5897
+                              Store 5753(result) 5899
+            5900:    7(fvec4) FunctionCall 111(testSparseTextureGradOffsetClamp()
+            5901:    7(fvec4) Load 5753(result)
+            5902:    7(fvec4) FAdd 5901 5900
+                              Store 5753(result) 5902
+            5903:    7(fvec4) FunctionCall 113(testTextureGradOffsetClamp()
+            5904:    7(fvec4) Load 5753(result)
+            5905:    7(fvec4) FAdd 5904 5903
+                              Store 5753(result) 5905
+            5906:    7(fvec4) FunctionCall 115(testCombinedTextureSampler()
+            5907:    7(fvec4) Load 5753(result)
+            5908:    7(fvec4) FAdd 5907 5906
+                              Store 5753(result) 5908
+            5909:    7(fvec4) FunctionCall 117(testSubpassLoad()
+            5910:    7(fvec4) Load 5753(result)
+            5911:    7(fvec4) FAdd 5910 5909
+                              Store 5753(result) 5911
+            5914:    7(fvec4) Load 5753(result)
+            5915:  249(fvec4) FConvert 5914
+                              Store 5913(fragColor) 5915
+                              Return
+                              FunctionEnd
+ 9(testTexture():    7(fvec4) Function None 8
+              10:             Label
+      119(texel):     64(ptr) Variable Function
+                              Store 119(texel) 121
+             126:         123 Load 125(s1D)
+             129:   52(float) Load 128(c1)
+             130:    7(fvec4) ImageSampleImplicitLod 126 129
+             131:    7(fvec4) Load 119(texel)
+             132:    7(fvec4) FAdd 131 130
+                              Store 119(texel) 132
+             133:         123 Load 125(s1D)
+             136:    6(float) Load 135(f16c1)
+             138:    6(float) Load 137(f16bias)
+             139:    7(fvec4) ImageSampleImplicitLod 133 136 Bias 138
+             140:    7(fvec4) Load 119(texel)
+             141:    7(fvec4) FAdd 140 139
+                              Store 119(texel) 141
+             146:         143 Load 145(s2D)
+             149:   53(fvec2) Load 148(c2)
+             150:    7(fvec4) ImageSampleImplicitLod 146 149
+             151:    7(fvec4) Load 119(texel)
+             152:    7(fvec4) FAdd 151 150
+                              Store 119(texel) 152
+             153:         143 Load 145(s2D)
+             157:  154(fvec2) Load 156(f16c2)
+             158:    6(float) Load 137(f16bias)
+             159:    7(fvec4) ImageSampleImplicitLod 153 157 Bias 158
+             160:    7(fvec4) Load 119(texel)
+             161:    7(fvec4) FAdd 160 159
+                              Store 119(texel) 161
+             166:         163 Load 165(s3D)
+             170:  167(fvec3) Load 169(c3)
+             171:    7(fvec4) ImageSampleImplicitLod 166 170
+             172:    7(fvec4) Load 119(texel)
+             173:    7(fvec4) FAdd 172 171
+                              Store 119(texel) 173
+             174:         163 Load 165(s3D)
+             178:  175(fvec3) Load 177(f16c3)
+             179:    6(float) Load 137(f16bias)
+             180:    7(fvec4) ImageSampleImplicitLod 174 178 Bias 179
+             181:    7(fvec4) Load 119(texel)
+             182:    7(fvec4) FAdd 181 180
+                              Store 119(texel) 182
+             187:         184 Load 186(sCube)
+             188:  167(fvec3) Load 169(c3)
+             189:    7(fvec4) ImageSampleImplicitLod 187 188
+             190:    7(fvec4) Load 119(texel)
+             191:    7(fvec4) FAdd 190 189
+                              Store 119(texel) 191
+             192:         184 Load 186(sCube)
+             193:  175(fvec3) Load 177(f16c3)
+             194:    6(float) Load 137(f16bias)
+             195:    7(fvec4) ImageSampleImplicitLod 192 193 Bias 194
+             196:    7(fvec4) Load 119(texel)
+             197:    7(fvec4) FAdd 196 195
+                              Store 119(texel) 197
+             202:         199 Load 201(s1DShadow)
+             203:  167(fvec3) Load 169(c3)
+             204:   52(float) CompositeExtract 203 2
+             205:    6(float) ImageSampleDrefImplicitLod 202 203 204
+             209:    208(ptr) AccessChain 119(texel) 207
+             210:    6(float) Load 209
+             211:    6(float) FAdd 210 205
+             212:    208(ptr) AccessChain 119(texel) 207
+                              Store 212 211
+             213:         199 Load 201(s1DShadow)
+             214:  154(fvec2) Load 156(f16c2)
+             216:   52(float) Load 215(compare)
+             217:    6(float) Load 137(f16bias)
+             218:    6(float) ImageSampleDrefImplicitLod 213 214 216 Bias 217
+             219:    208(ptr) AccessChain 119(texel) 207
+             220:    6(float) Load 219
+             221:    6(float) FAdd 220 218
+             222:    208(ptr) AccessChain 119(texel) 207
+                              Store 222 221
+             227:         224 Load 226(s2DShadow)
+             228:  167(fvec3) Load 169(c3)
+             229:   52(float) CompositeExtract 228 2
+             230:    6(float) ImageSampleDrefImplicitLod 227 228 229
+             231:    208(ptr) AccessChain 119(texel) 207
+             232:    6(float) Load 231
+             233:    6(float) FAdd 232 230
+             234:    208(ptr) AccessChain 119(texel) 207
+                              Store 234 233
+             235:         224 Load 226(s2DShadow)
+             236:  154(fvec2) Load 156(f16c2)
+             237:   52(float) Load 215(compare)
+             238:    6(float) Load 137(f16bias)
+             239:    6(float) ImageSampleDrefImplicitLod 235 236 237 Bias 238
+             240:    208(ptr) AccessChain 119(texel) 207
+             241:    6(float) Load 240
+             242:    6(float) FAdd 241 239
+             243:    208(ptr) AccessChain 119(texel) 207
+                              Store 243 242
+             248:         245 Load 247(sCubeShadow)
+             252:  249(fvec4) Load 251(c4)
+             253:   52(float) CompositeExtract 252 3
+             254:    6(float) ImageSampleDrefImplicitLod 248 252 253
+             255:    208(ptr) AccessChain 119(texel) 207
+             256:    6(float) Load 255
+             257:    6(float) FAdd 256 254
+             258:    208(ptr) AccessChain 119(texel) 207
+                              Store 258 257
+             259:         245 Load 247(sCubeShadow)
+             260:  175(fvec3) Load 177(f16c3)
+             261:   52(float) Load 215(compare)
+             262:    6(float) Load 137(f16bias)
+             263:    6(float) ImageSampleDrefImplicitLod 259 260 261 Bias 262
+             264:    208(ptr) AccessChain 119(texel) 207
+             265:    6(float) Load 264
+             266:    6(float) FAdd 265 263
+             267:    208(ptr) AccessChain 119(texel) 207
+                              Store 267 266
+             272:         269 Load 271(s1DArray)
+             273:   53(fvec2) Load 148(c2)
+             274:    7(fvec4) ImageSampleImplicitLod 272 273
+             275:    7(fvec4) Load 119(texel)
+             276:    7(fvec4) FAdd 275 274
+                              Store 119(texel) 276
+             277:         269 Load 271(s1DArray)
+             278:  154(fvec2) Load 156(f16c2)
+             279:    6(float) Load 137(f16bias)
+             280:    7(fvec4) ImageSampleImplicitLod 277 278 Bias 279
+             281:    7(fvec4) Load 119(texel)
+             282:    7(fvec4) FAdd 281 280
+                              Store 119(texel) 282
+             287:         284 Load 286(s2DArray)
+             288:  167(fvec3) Load 169(c3)
+             289:    7(fvec4) ImageSampleImplicitLod 287 288
+             290:    7(fvec4) Load 119(texel)
+             291:    7(fvec4) FAdd 290 289
+                              Store 119(texel) 291
+             292:         284 Load 286(s2DArray)
+             293:  175(fvec3) Load 177(f16c3)
+             294:    6(float) Load 137(f16bias)
+             295:    7(fvec4) ImageSampleImplicitLod 292 293 Bias 294
+             296:    7(fvec4) Load 119(texel)
+             297:    7(fvec4) FAdd 296 295
+                              Store 119(texel) 297
+             302:         299 Load 301(sCubeArray)
+             303:  249(fvec4) Load 251(c4)
+             304:    7(fvec4) ImageSampleImplicitLod 302 303
+             305:    7(fvec4) Load 119(texel)
+             306:    7(fvec4) FAdd 305 304
+                              Store 119(texel) 306
+             307:         299 Load 301(sCubeArray)
+             310:    7(fvec4) Load 309(f16c4)
+             311:    6(float) Load 137(f16bias)
+             312:    7(fvec4) ImageSampleImplicitLod 307 310 Bias 311
+             313:    7(fvec4) Load 119(texel)
+             314:    7(fvec4) FAdd 313 312
+                              Store 119(texel) 314
+             319:         316 Load 318(s1DArrayShadow)
+             320:  167(fvec3) Load 169(c3)
+             321:   52(float) CompositeExtract 320 2
+             322:    6(float) ImageSampleDrefImplicitLod 319 320 321
+             323:    208(ptr) AccessChain 119(texel) 207
+             324:    6(float) Load 323
+             325:    6(float) FAdd 324 322
+             326:    208(ptr) AccessChain 119(texel) 207
+                              Store 326 325
+             327:         316 Load 318(s1DArrayShadow)
+             328:  154(fvec2) Load 156(f16c2)
+             329:   52(float) Load 215(compare)
+             330:    6(float) Load 137(f16bias)
+             331:    6(float) ImageSampleDrefImplicitLod 327 328 329 Bias 330
+             332:    208(ptr) AccessChain 119(texel) 207
+             333:    6(float) Load 332
+             334:    6(float) FAdd 333 331
+             335:    208(ptr) AccessChain 119(texel) 207
+                              Store 335 334
+             340:         337 Load 339(s2DArrayShadow)
+             341:  249(fvec4) Load 251(c4)
+             342:   52(float) CompositeExtract 341 3
+             343:    6(float) ImageSampleDrefImplicitLod 340 341 342
+             344:    208(ptr) AccessChain 119(texel) 207
+             345:    6(float) Load 344
+             346:    6(float) FAdd 345 343
+             347:    208(ptr) AccessChain 119(texel) 207
+                              Store 347 346
+             348:         337 Load 339(s2DArrayShadow)
+             349:  175(fvec3) Load 177(f16c3)
+             350:   52(float) Load 215(compare)
+             351:    6(float) ImageSampleDrefImplicitLod 348 349 350
+             352:    208(ptr) AccessChain 119(texel) 207
+             353:    6(float) Load 352
+             354:    6(float) FAdd 353 351
+             355:    208(ptr) AccessChain 119(texel) 207
+                              Store 355 354
+             360:         357 Load 359(s2DRect)
+             361:   53(fvec2) Load 148(c2)
+             362:    7(fvec4) ImageSampleImplicitLod 360 361
+             363:    7(fvec4) Load 119(texel)
+             364:    7(fvec4) FAdd 363 362
+                              Store 119(texel) 364
+             365:         357 Load 359(s2DRect)
+             366:  154(fvec2) Load 156(f16c2)
+             367:    7(fvec4) ImageSampleImplicitLod 365 366
+             368:    7(fvec4) Load 119(texel)
+             369:    7(fvec4) FAdd 368 367
+                              Store 119(texel) 369
+             374:         371 Load 373(s2DRectShadow)
+             375:  167(fvec3) Load 169(c3)
+             376:   52(float) CompositeExtract 375 2
+             377:    6(float) ImageSampleDrefImplicitLod 374 375 376
+             378:    208(ptr) AccessChain 119(texel) 207
+             379:    6(float) Load 378
+             380:    6(float) FAdd 379 377
+             381:    208(ptr) AccessChain 119(texel) 207
+                              Store 381 380
+             382:         371 Load 373(s2DRectShadow)
+             383:  154(fvec2) Load 156(f16c2)
+             384:   52(float) Load 215(compare)
+             385:    6(float) ImageSampleDrefImplicitLod 382 383 384
+             386:    208(ptr) AccessChain 119(texel) 207
+             387:    6(float) Load 386
+             388:    6(float) FAdd 387 385
+             389:    208(ptr) AccessChain 119(texel) 207
+                              Store 389 388
+             394:         391 Load 393(sCubeArrayShadow)
+             395:  249(fvec4) Load 251(c4)
+             396:   52(float) Load 215(compare)
+             397:    6(float) ImageSampleDrefImplicitLod 394 395 396
+             398:    208(ptr) AccessChain 119(texel) 207
+             399:    6(float) Load 398
+             400:    6(float) FAdd 399 397
+             401:    208(ptr) AccessChain 119(texel) 207
+                              Store 401 400
+             402:         391 Load 393(sCubeArrayShadow)
+             403:    7(fvec4) Load 309(f16c4)
+             404:   52(float) Load 215(compare)
+             405:    6(float) ImageSampleDrefImplicitLod 402 403 404
+             406:    208(ptr) AccessChain 119(texel) 207
+             407:    6(float) Load 406
+             408:    6(float) FAdd 407 405
+             409:    208(ptr) AccessChain 119(texel) 207
+                              Store 409 408
+             410:    7(fvec4) Load 119(texel)
+                              ReturnValue 410
+                              FunctionEnd
+11(testTextureProj():    7(fvec4) Function None 8
+              12:             Label
+      413(texel):     64(ptr) Variable Function
+                              Store 413(texel) 121
+             414:         123 Load 125(s1D)
+             415:   53(fvec2) Load 148(c2)
+             416:    7(fvec4) ImageSampleProjImplicitLod 414 415
+             417:    7(fvec4) Load 413(texel)
+             418:    7(fvec4) FAdd 417 416
+                              Store 413(texel) 418
+             419:         123 Load 125(s1D)
+             420:  154(fvec2) Load 156(f16c2)
+             421:    6(float) Load 137(f16bias)
+             422:    7(fvec4) ImageSampleProjImplicitLod 419 420 Bias 421
+             423:    7(fvec4) Load 413(texel)
+             424:    7(fvec4) FAdd 423 422
+                              Store 413(texel) 424
+             425:         123 Load 125(s1D)
+             426:  249(fvec4) Load 251(c4)
+             427:   52(float) CompositeExtract 426 3
+             428:  249(fvec4) CompositeInsert 427 426 1
+             429:    7(fvec4) ImageSampleProjImplicitLod 425 428
+             430:    7(fvec4) Load 413(texel)
+             431:    7(fvec4) FAdd 430 429
+                              Store 413(texel) 431
+             432:         123 Load 125(s1D)
+             433:    7(fvec4) Load 309(f16c4)
+             434:    6(float) Load 137(f16bias)
+             435:    6(float) CompositeExtract 433 3
+             436:    7(fvec4) CompositeInsert 435 433 1
+             437:    7(fvec4) ImageSampleProjImplicitLod 432 436 Bias 434
+             438:    7(fvec4) Load 413(texel)
+             439:    7(fvec4) FAdd 438 437
+                              Store 413(texel) 439
+             440:         143 Load 145(s2D)
+             441:  167(fvec3) Load 169(c3)
+             442:    7(fvec4) ImageSampleProjImplicitLod 440 441
+             443:    7(fvec4) Load 413(texel)
+             444:    7(fvec4) FAdd 443 442
+                              Store 413(texel) 444
+             445:         143 Load 145(s2D)
+             446:  175(fvec3) Load 177(f16c3)
+             447:    6(float) Load 137(f16bias)
+             448:    7(fvec4) ImageSampleProjImplicitLod 445 446 Bias 447
+             449:    7(fvec4) Load 413(texel)
+             450:    7(fvec4) FAdd 449 448
+                              Store 413(texel) 450
+             451:         143 Load 145(s2D)
+             452:  249(fvec4) Load 251(c4)
+             453:   52(float) CompositeExtract 452 3
+             454:  249(fvec4) CompositeInsert 453 452 2
+             455:    7(fvec4) ImageSampleProjImplicitLod 451 454
+             456:    7(fvec4) Load 413(texel)
+             457:    7(fvec4) FAdd 456 455
+                              Store 413(texel) 457
+             458:         143 Load 145(s2D)
+             459:    7(fvec4) Load 309(f16c4)
+             460:    6(float) Load 137(f16bias)
+             461:    6(float) CompositeExtract 459 3
+             462:    7(fvec4) CompositeInsert 461 459 2
+             463:    7(fvec4) ImageSampleProjImplicitLod 458 462 Bias 460
+             464:    7(fvec4) Load 413(texel)
+             465:    7(fvec4) FAdd 464 463
+                              Store 413(texel) 465
+             466:         163 Load 165(s3D)
+             467:  249(fvec4) Load 251(c4)
+             468:    7(fvec4) ImageSampleProjImplicitLod 466 467
+             469:    7(fvec4) Load 413(texel)
+             470:    7(fvec4) FAdd 469 468
+                              Store 413(texel) 470
+             471:         163 Load 165(s3D)
+             472:    7(fvec4) Load 309(f16c4)
+             473:    6(float) Load 137(f16bias)
+             474:    7(fvec4) ImageSampleProjImplicitLod 471 472 Bias 473
+             475:    7(fvec4) Load 413(texel)
+             476:    7(fvec4) FAdd 475 474
+                              Store 413(texel) 476
+             477:         199 Load 201(s1DShadow)
+             478:  249(fvec4) Load 251(c4)
+             479:   52(float) CompositeExtract 478 2
+             480:   52(float) CompositeExtract 478 3
+             481:  249(fvec4) CompositeInsert 480 478 1
+             482:    6(float) ImageSampleProjDrefImplicitLod 477 481 479
+             483:    208(ptr) AccessChain 413(texel) 207
+             484:    6(float) Load 483
+             485:    6(float) FAdd 484 482
+             486:    208(ptr) AccessChain 413(texel) 207
+                              Store 486 485
+             487:         199 Load 201(s1DShadow)
+             488:  175(fvec3) Load 177(f16c3)
+             489:   52(float) Load 215(compare)
+             490:    6(float) Load 137(f16bias)
+             491:    6(float) CompositeExtract 488 2
+             492:  175(fvec3) CompositeInsert 491 488 1
+             493:    6(float) ImageSampleProjDrefImplicitLod 487 492 489 Bias 490
+             494:    208(ptr) AccessChain 413(texel) 207
+             495:    6(float) Load 494
+             496:    6(float) FAdd 495 493
+             497:    208(ptr) AccessChain 413(texel) 207
+                              Store 497 496
+             498:         224 Load 226(s2DShadow)
+             499:  249(fvec4) Load 251(c4)
+             500:   52(float) CompositeExtract 499 2
+             501:   52(float) CompositeExtract 499 3
+             502:  249(fvec4) CompositeInsert 501 499 2
+             503:    6(float) ImageSampleProjDrefImplicitLod 498 502 500
+             504:    208(ptr) AccessChain 413(texel) 207
+             505:    6(float) Load 504
+             506:    6(float) FAdd 505 503
+             507:    208(ptr) AccessChain 413(texel) 207
+                              Store 507 506
+             508:         224 Load 226(s2DShadow)
+             509:  175(fvec3) Load 177(f16c3)
+             510:   52(float) Load 215(compare)
+             511:    6(float) Load 137(f16bias)
+             512:    6(float) ImageSampleProjDrefImplicitLod 508 509 510 Bias 511
+             513:    208(ptr) AccessChain 413(texel) 207
+             514:    6(float) Load 513
+             515:    6(float) FAdd 514 512
+             516:    208(ptr) AccessChain 413(texel) 207
+                              Store 516 515
+             517:         357 Load 359(s2DRect)
+             518:  167(fvec3) Load 169(c3)
+             519:    7(fvec4) ImageSampleProjImplicitLod 517 518
+             520:    7(fvec4) Load 413(texel)
+             521:    7(fvec4) FAdd 520 519
+                              Store 413(texel) 521
+             522:         357 Load 359(s2DRect)
+             523:  175(fvec3) Load 177(f16c3)
+             524:    7(fvec4) ImageSampleProjImplicitLod 522 523
+             525:    7(fvec4) Load 413(texel)
+             526:    7(fvec4) FAdd 525 524
+                              Store 413(texel) 526
+             527:         357 Load 359(s2DRect)
+             528:  249(fvec4) Load 251(c4)
+             529:   52(float) CompositeExtract 528 3
+             530:  249(fvec4) CompositeInsert 529 528 2
+             531:    7(fvec4) ImageSampleProjImplicitLod 527 530
+             532:    7(fvec4) Load 413(texel)
+             533:    7(fvec4) FAdd 532 531
+                              Store 413(texel) 533
+             534:         357 Load 359(s2DRect)
+             535:    7(fvec4) Load 309(f16c4)
+             536:    6(float) CompositeExtract 535 3
+             537:    7(fvec4) CompositeInsert 536 535 2
+             538:    7(fvec4) ImageSampleProjImplicitLod 534 537
+             539:    7(fvec4) Load 413(texel)
+             540:    7(fvec4) FAdd 539 538
+                              Store 413(texel) 540
+             541:         371 Load 373(s2DRectShadow)
+             542:  249(fvec4) Load 251(c4)
+             543:   52(float) CompositeExtract 542 2
+             544:   52(float) CompositeExtract 542 3
+             545:  249(fvec4) CompositeInsert 544 542 2
+             546:    6(float) ImageSampleProjDrefImplicitLod 541 545 543
+             547:    208(ptr) AccessChain 413(texel) 207
+             548:    6(float) Load 547
+             549:    6(float) FAdd 548 546
+             550:    208(ptr) AccessChain 413(texel) 207
+                              Store 550 549
+             551:         371 Load 373(s2DRectShadow)
+             552:  175(fvec3) Load 177(f16c3)
+             553:   52(float) Load 215(compare)
+             554:    6(float) ImageSampleProjDrefImplicitLod 551 552 553
+             555:    208(ptr) AccessChain 413(texel) 207
+             556:    6(float) Load 555
+             557:    6(float) FAdd 556 554
+             558:    208(ptr) AccessChain 413(texel) 207
+                              Store 558 557
+             559:    7(fvec4) Load 413(texel)
+                              ReturnValue 559
+                              FunctionEnd
+13(testTextureLod():    7(fvec4) Function None 8
+              14:             Label
+      562(texel):     64(ptr) Variable Function
+                              Store 562(texel) 121
+             563:         123 Load 125(s1D)
+             564:   52(float) Load 128(c1)
+             566:   52(float) Load 565(lod)
+             567:    7(fvec4) ImageSampleExplicitLod 563 564 Lod 566
+             568:    7(fvec4) Load 562(texel)
+             569:    7(fvec4) FAdd 568 567
+                              Store 562(texel) 569
+             570:         123 Load 125(s1D)
+             571:    6(float) Load 135(f16c1)
+             573:    6(float) Load 572(f16lod)
+             574:    7(fvec4) ImageSampleExplicitLod 570 571 Lod 573
+             575:    7(fvec4) Load 562(texel)
+             576:    7(fvec4) FAdd 575 574
+                              Store 562(texel) 576
+             577:         143 Load 145(s2D)
+             578:   53(fvec2) Load 148(c2)
+             579:   52(float) Load 565(lod)
+             580:    7(fvec4) ImageSampleExplicitLod 577 578 Lod 579
+             581:    7(fvec4) Load 562(texel)
+             582:    7(fvec4) FAdd 581 580
+                              Store 562(texel) 582
+             583:         143 Load 145(s2D)
+             584:  154(fvec2) Load 156(f16c2)
+             585:    6(float) Load 572(f16lod)
+             586:    7(fvec4) ImageSampleExplicitLod 583 584 Lod 585
+             587:    7(fvec4) Load 562(texel)
+             588:    7(fvec4) FAdd 587 586
+                              Store 562(texel) 588
+             589:         163 Load 165(s3D)
+             590:  167(fvec3) Load 169(c3)
+             591:   52(float) Load 565(lod)
+             592:    7(fvec4) ImageSampleExplicitLod 589 590 Lod 591
+             593:    7(fvec4) Load 562(texel)
+             594:    7(fvec4) FAdd 593 592
+                              Store 562(texel) 594
+             595:         163 Load 165(s3D)
+             596:  175(fvec3) Load 177(f16c3)
+             597:    6(float) Load 572(f16lod)
+             598:    7(fvec4) ImageSampleExplicitLod 595 596 Lod 597
+             599:    7(fvec4) Load 562(texel)
+             600:    7(fvec4) FAdd 599 598
+                              Store 562(texel) 600
+             601:         184 Load 186(sCube)
+             602:  167(fvec3) Load 169(c3)
+             603:   52(float) Load 565(lod)
+             604:    7(fvec4) ImageSampleExplicitLod 601 602 Lod 603
+             605:    7(fvec4) Load 562(texel)
+             606:    7(fvec4) FAdd 605 604
+                              Store 562(texel) 606
+             607:         184 Load 186(sCube)
+             608:  175(fvec3) Load 177(f16c3)
+             609:    6(float) Load 572(f16lod)
+             610:    7(fvec4) ImageSampleExplicitLod 607 608 Lod 609
+             611:    7(fvec4) Load 562(texel)
+             612:    7(fvec4) FAdd 611 610
+                              Store 562(texel) 612
+             613:         199 Load 201(s1DShadow)
+             614:  167(fvec3) Load 169(c3)
+             615:   52(float) Load 565(lod)
+             616:   52(float) CompositeExtract 614 2
+             617:    6(float) ImageSampleDrefExplicitLod 613 614 616 Lod 615
+             618:    208(ptr) AccessChain 562(texel) 207
+             619:    6(float) Load 618
+             620:    6(float) FAdd 619 617
+             621:    208(ptr) AccessChain 562(texel) 207
+                              Store 621 620
+             622:         199 Load 201(s1DShadow)
+             623:  154(fvec2) Load 156(f16c2)
+             624:   52(float) Load 215(compare)
+             625:    6(float) Load 572(f16lod)
+             626:    6(float) ImageSampleDrefExplicitLod 622 623 624 Lod 625
+             627:    208(ptr) AccessChain 562(texel) 207
+             628:    6(float) Load 627
+             629:    6(float) FAdd 628 626
+             630:    208(ptr) AccessChain 562(texel) 207
+                              Store 630 629
+             631:         224 Load 226(s2DShadow)
+             632:  167(fvec3) Load 169(c3)
+             633:   52(float) Load 565(lod)
+             634:   52(float) CompositeExtract 632 2
+             635:    6(float) ImageSampleDrefExplicitLod 631 632 634 Lod 633
+             636:    208(ptr) AccessChain 562(texel) 207
+             637:    6(float) Load 636
+             638:    6(float) FAdd 637 635
+             639:    208(ptr) AccessChain 562(texel) 207
+                              Store 639 638
+             640:         224 Load 226(s2DShadow)
+             641:  154(fvec2) Load 156(f16c2)
+             642:   52(float) Load 215(compare)
+             643:    6(float) Load 572(f16lod)
+             644:    6(float) ImageSampleDrefExplicitLod 640 641 642 Lod 643
+             645:    208(ptr) AccessChain 562(texel) 207
+             646:    6(float) Load 645
+             647:    6(float) FAdd 646 644
+             648:    208(ptr) AccessChain 562(texel) 207
+                              Store 648 647
+             649:         269 Load 271(s1DArray)
+             650:   53(fvec2) Load 148(c2)
+             651:   52(float) Load 565(lod)
+             652:    7(fvec4) ImageSampleExplicitLod 649 650 Lod 651
+             653:    7(fvec4) Load 562(texel)
+             654:    7(fvec4) FAdd 653 652
+                              Store 562(texel) 654
+             655:         269 Load 271(s1DArray)
+             656:  154(fvec2) Load 156(f16c2)
+             657:    6(float) Load 572(f16lod)
+             658:    7(fvec4) ImageSampleExplicitLod 655 656 Lod 657
+             659:    7(fvec4) Load 562(texel)
+             660:    7(fvec4) FAdd 659 658
+                              Store 562(texel) 660
+             661:         284 Load 286(s2DArray)
+             662:  167(fvec3) Load 169(c3)
+             663:   52(float) Load 565(lod)
+             664:    7(fvec4) ImageSampleExplicitLod 661 662 Lod 663
+             665:    7(fvec4) Load 562(texel)
+             666:    7(fvec4) FAdd 665 664
+                              Store 562(texel) 666
+             667:         284 Load 286(s2DArray)
+             668:  175(fvec3) Load 177(f16c3)
+             669:    6(float) Load 572(f16lod)
+             670:    7(fvec4) ImageSampleExplicitLod 667 668 Lod 669
+             671:    7(fvec4) Load 562(texel)
+             672:    7(fvec4) FAdd 671 670
+                              Store 562(texel) 672
+             673:         316 Load 318(s1DArrayShadow)
+             674:  167(fvec3) Load 169(c3)
+             675:   52(float) Load 565(lod)
+             676:   52(float) CompositeExtract 674 2
+             677:    6(float) ImageSampleDrefExplicitLod 673 674 676 Lod 675
+             678:    208(ptr) AccessChain 562(texel) 207
+             679:    6(float) Load 678
+             680:    6(float) FAdd 679 677
+             681:    208(ptr) AccessChain 562(texel) 207
+                              Store 681 680
+             682:         316 Load 318(s1DArrayShadow)
+             683:  154(fvec2) Load 156(f16c2)
+             684:   52(float) Load 215(compare)
+             685:    6(float) Load 572(f16lod)
+             686:    6(float) ImageSampleDrefExplicitLod 682 683 684 Lod 685
+             687:    208(ptr) AccessChain 562(texel) 207
+             688:    6(float) Load 687
+             689:    6(float) FAdd 688 686
+             690:    208(ptr) AccessChain 562(texel) 207
+                              Store 690 689
+             691:         299 Load 301(sCubeArray)
+             692:  249(fvec4) Load 251(c4)
+             693:   52(float) Load 565(lod)
+             694:    7(fvec4) ImageSampleExplicitLod 691 692 Lod 693
+             695:    7(fvec4) Load 562(texel)
+             696:    7(fvec4) FAdd 695 694
+                              Store 562(texel) 696
+             697:         299 Load 301(sCubeArray)
+             698:    7(fvec4) Load 309(f16c4)
+             699:    6(float) Load 572(f16lod)
+             700:    7(fvec4) ImageSampleExplicitLod 697 698 Lod 699
+             701:    7(fvec4) Load 562(texel)
+             702:    7(fvec4) FAdd 701 700
+                              Store 562(texel) 702
+             703:    7(fvec4) Load 562(texel)
+                              ReturnValue 703
+                              FunctionEnd
+15(testTextureOffset():    7(fvec4) Function None 8
+              16:             Label
+      706(texel):     64(ptr) Variable Function
+                              Store 706(texel) 121
+             707:         123 Load 125(s1D)
+             708:   52(float) Load 128(c1)
+             710:    7(fvec4) ImageSampleImplicitLod 707 708 ConstOffset 709
+             711:    7(fvec4) Load 706(texel)
+             712:    7(fvec4) FAdd 711 710
+                              Store 706(texel) 712
+             713:         123 Load 125(s1D)
+             714:    6(float) Load 135(f16c1)
+             715:    6(float) Load 137(f16bias)
+             716:    7(fvec4) ImageSampleImplicitLod 713 714 Bias ConstOffset 715 709
+             717:    7(fvec4) Load 706(texel)
+             718:    7(fvec4) FAdd 717 716
+                              Store 706(texel) 718
+             719:         143 Load 145(s2D)
+             720:   53(fvec2) Load 148(c2)
+             723:    7(fvec4) ImageSampleImplicitLod 719 720 ConstOffset 722
+             724:    7(fvec4) Load 706(texel)
+             725:    7(fvec4) FAdd 724 723
+                              Store 706(texel) 725
+             726:         143 Load 145(s2D)
+             727:  154(fvec2) Load 156(f16c2)
+             728:    6(float) Load 137(f16bias)
+             729:    7(fvec4) ImageSampleImplicitLod 726 727 Bias ConstOffset 728 722
+             730:    7(fvec4) Load 706(texel)
+             731:    7(fvec4) FAdd 730 729
+                              Store 706(texel) 731
+             732:         163 Load 165(s3D)
+             733:  167(fvec3) Load 169(c3)
+             736:    7(fvec4) ImageSampleImplicitLod 732 733 ConstOffset 735
+             737:    7(fvec4) Load 706(texel)
+             738:    7(fvec4) FAdd 737 736
+                              Store 706(texel) 738
+             739:         163 Load 165(s3D)
+             740:  175(fvec3) Load 177(f16c3)
+             741:    6(float) Load 137(f16bias)
+             742:    7(fvec4) ImageSampleImplicitLod 739 740 Bias ConstOffset 741 735
+             743:    7(fvec4) Load 706(texel)
+             744:    7(fvec4) FAdd 743 742
+                              Store 706(texel) 744
+             745:         357 Load 359(s2DRect)
+             746:   53(fvec2) Load 148(c2)
+             747:    7(fvec4) ImageSampleImplicitLod 745 746 ConstOffset 722
+             748:    7(fvec4) Load 706(texel)
+             749:    7(fvec4) FAdd 748 747
+                              Store 706(texel) 749
+             750:         357 Load 359(s2DRect)
+             751:  154(fvec2) Load 156(f16c2)
+             752:    7(fvec4) ImageSampleImplicitLod 750 751 ConstOffset 722
+             753:    7(fvec4) Load 706(texel)
+             754:    7(fvec4) FAdd 753 752
+                              Store 706(texel) 754
+             755:         371 Load 373(s2DRectShadow)
+             756:  167(fvec3) Load 169(c3)
+             757:   52(float) CompositeExtract 756 2
+             758:    6(float) ImageSampleDrefImplicitLod 755 756 757 ConstOffset 722
+             759:    208(ptr) AccessChain 706(texel) 207
+             760:    6(float) Load 759
+             761:    6(float) FAdd 760 758
+             762:    208(ptr) AccessChain 706(texel) 207
+                              Store 762 761
+             763:         371 Load 373(s2DRectShadow)
+             764:  154(fvec2) Load 156(f16c2)
+             765:   52(float) Load 215(compare)
+             766:    6(float) ImageSampleDrefImplicitLod 763 764 765 ConstOffset 722
+             767:    208(ptr) AccessChain 706(texel) 207
+             768:    6(float) Load 767
+             769:    6(float) FAdd 768 766
+             770:    208(ptr) AccessChain 706(texel) 207
+                              Store 770 769
+             771:         199 Load 201(s1DShadow)
+             772:  167(fvec3) Load 169(c3)
+             773:   52(float) CompositeExtract 772 2
+             774:    6(float) ImageSampleDrefImplicitLod 771 772 773 ConstOffset 709
+             775:    208(ptr) AccessChain 706(texel) 207
+             776:    6(float) Load 775
+             777:    6(float) FAdd 776 774
+             778:    208(ptr) AccessChain 706(texel) 207
+                              Store 778 777
+             779:         199 Load 201(s1DShadow)
+             780:  154(fvec2) Load 156(f16c2)
+             781:   52(float) Load 215(compare)
+             782:    6(float) Load 137(f16bias)
+             783:    6(float) ImageSampleDrefImplicitLod 779 780 781 Bias ConstOffset 782 709
+             784:    208(ptr) AccessChain 706(texel) 207
+             785:    6(float) Load 784
+             786:    6(float) FAdd 785 783
+             787:    208(ptr) AccessChain 706(texel) 207
+                              Store 787 786
+             788:         224 Load 226(s2DShadow)
+             789:  167(fvec3) Load 169(c3)
+             790:   52(float) CompositeExtract 789 2
+             791:    6(float) ImageSampleDrefImplicitLod 788 789 790 ConstOffset 722
+             792:    208(ptr) AccessChain 706(texel) 207
+             793:    6(float) Load 792
+             794:    6(float) FAdd 793 791
+             795:    208(ptr) AccessChain 706(texel) 207
+                              Store 795 794
+             796:         224 Load 226(s2DShadow)
+             797:  154(fvec2) Load 156(f16c2)
+             798:   52(float) Load 215(compare)
+             799:    6(float) Load 137(f16bias)
+             800:    6(float) ImageSampleDrefImplicitLod 796 797 798 Bias ConstOffset 799 722
+             801:    208(ptr) AccessChain 706(texel) 207
+             802:    6(float) Load 801
+             803:    6(float) FAdd 802 800
+             804:    208(ptr) AccessChain 706(texel) 207
+                              Store 804 803
+             805:         269 Load 271(s1DArray)
+             806:   53(fvec2) Load 148(c2)
+             807:    7(fvec4) ImageSampleImplicitLod 805 806 ConstOffset 709
+             808:    7(fvec4) Load 706(texel)
+             809:    7(fvec4) FAdd 808 807
+                              Store 706(texel) 809
+             810:         269 Load 271(s1DArray)
+             811:  154(fvec2) Load 156(f16c2)
+             812:    6(float) Load 137(f16bias)
+             813:    7(fvec4) ImageSampleImplicitLod 810 811 Bias ConstOffset 812 709
+             814:    7(fvec4) Load 706(texel)
+             815:    7(fvec4) FAdd 814 813
+                              Store 706(texel) 815
+             816:         284 Load 286(s2DArray)
+             817:  167(fvec3) Load 169(c3)
+             818:    7(fvec4) ImageSampleImplicitLod 816 817 ConstOffset 722
+             819:    7(fvec4) Load 706(texel)
+             820:    7(fvec4) FAdd 819 818
+                              Store 706(texel) 820
+             821:         284 Load 286(s2DArray)
+             822:  175(fvec3) Load 177(f16c3)
+             823:    6(float) Load 137(f16bias)
+             824:    7(fvec4) ImageSampleImplicitLod 821 822 Bias ConstOffset 823 722
+             825:    7(fvec4) Load 706(texel)
+             826:    7(fvec4) FAdd 825 824
+                              Store 706(texel) 826
+             827:         316 Load 318(s1DArrayShadow)
+             828:  167(fvec3) Load 169(c3)
+             829:   52(float) CompositeExtract 828 2
+             830:    6(float) ImageSampleDrefImplicitLod 827 828 829 ConstOffset 709
+             831:    208(ptr) AccessChain 706(texel) 207
+             832:    6(float) Load 831
+             833:    6(float) FAdd 832 830
+             834:    208(ptr) AccessChain 706(texel) 207
+                              Store 834 833
+             835:         316 Load 318(s1DArrayShadow)
+             836:  154(fvec2) Load 156(f16c2)
+             837:   52(float) Load 215(compare)
+             838:    6(float) Load 137(f16bias)
+             839:    6(float) ImageSampleDrefImplicitLod 835 836 837 Bias ConstOffset 838 709
+             840:    208(ptr) AccessChain 706(texel) 207
+             841:    6(float) Load 840
+             842:    6(float) FAdd 841 839
+             843:    208(ptr) AccessChain 706(texel) 207
+                              Store 843 842
+             844:         337 Load 339(s2DArrayShadow)
+             845:  249(fvec4) Load 251(c4)
+             846:   52(float) CompositeExtract 845 3
+             847:    6(float) ImageSampleDrefImplicitLod 844 845 846 ConstOffset 722
+             848:    208(ptr) AccessChain 706(texel) 207
+             849:    6(float) Load 848
+             850:    6(float) FAdd 849 847
+             851:    208(ptr) AccessChain 706(texel) 207
+                              Store 851 850
+             852:         337 Load 339(s2DArrayShadow)
+             853:  175(fvec3) Load 177(f16c3)
+             854:   52(float) Load 215(compare)
+             855:    6(float) ImageSampleDrefImplicitLod 852 853 854 ConstOffset 722
+             856:    208(ptr) AccessChain 706(texel) 207
+             857:    6(float) Load 856
+             858:    6(float) FAdd 857 855
+             859:    208(ptr) AccessChain 706(texel) 207
+                              Store 859 858
+             860:    7(fvec4) Load 706(texel)
+                              ReturnValue 860
+                              FunctionEnd
+17(testTextureProjOffset():    7(fvec4) Function None 8
+              18:             Label
+      863(texel):     64(ptr) Variable Function
+                              Store 863(texel) 121
+             864:         123 Load 125(s1D)
+             865:   53(fvec2) Load 148(c2)
+             866:    7(fvec4) ImageSampleProjImplicitLod 864 865 ConstOffset 709
+             867:    7(fvec4) Load 863(texel)
+             868:    7(fvec4) FAdd 867 866
+                              Store 863(texel) 868
+             869:         123 Load 125(s1D)
+             870:  154(fvec2) Load 156(f16c2)
+             871:    6(float) Load 137(f16bias)
+             872:    7(fvec4) ImageSampleProjImplicitLod 869 870 Bias ConstOffset 871 709
+             873:    7(fvec4) Load 863(texel)
+             874:    7(fvec4) FAdd 873 872
+                              Store 863(texel) 874
+             875:         123 Load 125(s1D)
+             876:  249(fvec4) Load 251(c4)
+             877:   52(float) CompositeExtract 876 3
+             878:  249(fvec4) CompositeInsert 877 876 1
+             879:    7(fvec4) ImageSampleProjImplicitLod 875 878 ConstOffset 709
+             880:    7(fvec4) Load 863(texel)
+             881:    7(fvec4) FAdd 880 879
+                              Store 863(texel) 881
+             882:         123 Load 125(s1D)
+             883:    7(fvec4) Load 309(f16c4)
+             884:    6(float) Load 137(f16bias)
+             885:    6(float) CompositeExtract 883 3
+             886:    7(fvec4) CompositeInsert 885 883 1
+             887:    7(fvec4) ImageSampleProjImplicitLod 882 886 Bias ConstOffset 884 709
+             888:    7(fvec4) Load 863(texel)
+             889:    7(fvec4) FAdd 888 887
+                              Store 863(texel) 889
+             890:         143 Load 145(s2D)
+             891:  167(fvec3) Load 169(c3)
+             892:    7(fvec4) ImageSampleProjImplicitLod 890 891 ConstOffset 722
+             893:    7(fvec4) Load 863(texel)
+             894:    7(fvec4) FAdd 893 892
+                              Store 863(texel) 894
+             895:         143 Load 145(s2D)
+             896:  175(fvec3) Load 177(f16c3)
+             897:    6(float) Load 137(f16bias)
+             898:    7(fvec4) ImageSampleProjImplicitLod 895 896 Bias ConstOffset 897 722
+             899:    7(fvec4) Load 863(texel)
+             900:    7(fvec4) FAdd 899 898
+                              Store 863(texel) 900
+             901:         143 Load 145(s2D)
+             902:  249(fvec4) Load 251(c4)
+             903:   52(float) CompositeExtract 902 3
+             904:  249(fvec4) CompositeInsert 903 902 2
+             905:    7(fvec4) ImageSampleProjImplicitLod 901 904 ConstOffset 722
+             906:    7(fvec4) Load 863(texel)
+             907:    7(fvec4) FAdd 906 905
+                              Store 863(texel) 907
+             908:         143 Load 145(s2D)
+             909:    7(fvec4) Load 309(f16c4)
+             910:    6(float) Load 137(f16bias)
+             911:    6(float) CompositeExtract 909 3
+             912:    7(fvec4) CompositeInsert 911 909 2
+             913:    7(fvec4) ImageSampleProjImplicitLod 908 912 Bias ConstOffset 910 722
+             914:    7(fvec4) Load 863(texel)
+             915:    7(fvec4) FAdd 914 913
+                              Store 863(texel) 915
+             916:         163 Load 165(s3D)
+             917:  249(fvec4) Load 251(c4)
+             918:    7(fvec4) ImageSampleProjImplicitLod 916 917 ConstOffset 735
+             919:    7(fvec4) Load 863(texel)
+             920:    7(fvec4) FAdd 919 918
+                              Store 863(texel) 920
+             921:         163 Load 165(s3D)
+             922:    7(fvec4) Load 309(f16c4)
+             923:    6(float) Load 137(f16bias)
+             924:    7(fvec4) ImageSampleProjImplicitLod 921 922 Bias ConstOffset 923 735
+             925:    7(fvec4) Load 863(texel)
+             926:    7(fvec4) FAdd 925 924
+                              Store 863(texel) 926
+             927:         357 Load 359(s2DRect)
+             928:  167(fvec3) Load 169(c3)
+             929:    7(fvec4) ImageSampleProjImplicitLod 927 928 ConstOffset 722
+             930:    7(fvec4) Load 863(texel)
+             931:    7(fvec4) FAdd 930 929
+                              Store 863(texel) 931
+             932:         357 Load 359(s2DRect)
+             933:  175(fvec3) Load 177(f16c3)
+             934:    7(fvec4) ImageSampleProjImplicitLod 932 933 ConstOffset 722
+             935:    7(fvec4) Load 863(texel)
+             936:    7(fvec4) FAdd 935 934
+                              Store 863(texel) 936
+             937:         357 Load 359(s2DRect)
+             938:  249(fvec4) Load 251(c4)
+             939:   52(float) CompositeExtract 938 3
+             940:  249(fvec4) CompositeInsert 939 938 2
+             941:    7(fvec4) ImageSampleProjImplicitLod 937 940 ConstOffset 722
+             942:    7(fvec4) Load 863(texel)
+             943:    7(fvec4) FAdd 942 941
+                              Store 863(texel) 943
+             944:         357 Load 359(s2DRect)
+             945:    7(fvec4) Load 309(f16c4)
+             946:    6(float) CompositeExtract 945 3
+             947:    7(fvec4) CompositeInsert 946 945 2
+             948:    7(fvec4) ImageSampleProjImplicitLod 944 947 ConstOffset 722
+             949:    7(fvec4) Load 863(texel)
+             950:    7(fvec4) FAdd 949 948
+                              Store 863(texel) 950
+             951:         371 Load 373(s2DRectShadow)
+             952:  249(fvec4) Load 251(c4)
+             953:   52(float) CompositeExtract 952 2
+             954:   52(float) CompositeExtract 952 3
+             955:  249(fvec4) CompositeInsert 954 952 2
+             956:    6(float) ImageSampleProjDrefImplicitLod 951 955 953 ConstOffset 722
+             957:    208(ptr) AccessChain 863(texel) 207
+             958:    6(float) Load 957
+             959:    6(float) FAdd 958 956
+             960:    208(ptr) AccessChain 863(texel) 207
+                              Store 960 959
+             961:         371 Load 373(s2DRectShadow)
+             962:  175(fvec3) Load 177(f16c3)
+             963:   52(float) Load 215(compare)
+             964:    6(float) ImageSampleProjDrefImplicitLod 961 962 963 ConstOffset 722
+             965:    208(ptr) AccessChain 863(texel) 207
+             966:    6(float) Load 965
+             967:    6(float) FAdd 966 964
+             968:    208(ptr) AccessChain 863(texel) 207
+                              Store 968 967
+             969:         199 Load 201(s1DShadow)
+             970:  249(fvec4) Load 251(c4)
+             971:   52(float) CompositeExtract 970 2
+             972:   52(float) CompositeExtract 970 3
+             973:  249(fvec4) CompositeInsert 972 970 1
+             974:    6(float) ImageSampleProjDrefImplicitLod 969 973 971 ConstOffset 709
+             975:    208(ptr) AccessChain 863(texel) 207
+             976:    6(float) Load 975
+             977:    6(float) FAdd 976 974
+             978:    208(ptr) AccessChain 863(texel) 207
+                              Store 978 977
+             979:         199 Load 201(s1DShadow)
+             980:  175(fvec3) Load 177(f16c3)
+             981:   52(float) Load 215(compare)
+             982:    6(float) Load 137(f16bias)
+             983:    6(float) CompositeExtract 980 2
+             984:  175(fvec3) CompositeInsert 983 980 1
+             985:    6(float) ImageSampleProjDrefImplicitLod 979 984 981 Bias ConstOffset 982 709
+             986:    208(ptr) AccessChain 863(texel) 207
+             987:    6(float) Load 986
+             988:    6(float) FAdd 987 985
+             989:    208(ptr) AccessChain 863(texel) 207
+                              Store 989 988
+             990:         224 Load 226(s2DShadow)
+             991:  249(fvec4) Load 251(c4)
+             992:   52(float) CompositeExtract 991 2
+             993:   52(float) CompositeExtract 991 3
+             994:  249(fvec4) CompositeInsert 993 991 2
+             995:    6(float) ImageSampleProjDrefImplicitLod 990 994 992 ConstOffset 722
+             996:    208(ptr) AccessChain 863(texel) 207
+             997:    6(float) Load 996
+             998:    6(float) FAdd 997 995
+             999:    208(ptr) AccessChain 863(texel) 207
+                              Store 999 998
+            1000:         224 Load 226(s2DShadow)
+            1001:  175(fvec3) Load 177(f16c3)
+            1002:   52(float) Load 215(compare)
+            1003:    6(float) Load 137(f16bias)
+            1004:    6(float) ImageSampleProjDrefImplicitLod 1000 1001 1002 Bias ConstOffset 1003 722
+            1005:    208(ptr) AccessChain 863(texel) 207
+            1006:    6(float) Load 1005
+            1007:    6(float) FAdd 1006 1004
+            1008:    208(ptr) AccessChain 863(texel) 207
+                              Store 1008 1007
+            1009:    7(fvec4) Load 863(texel)
+                              ReturnValue 1009
+                              FunctionEnd
+19(testTextureLodOffset():    7(fvec4) Function None 8
+              20:             Label
+     1012(texel):     64(ptr) Variable Function
+                              Store 1012(texel) 121
+            1013:         123 Load 125(s1D)
+            1014:   52(float) Load 128(c1)
+            1015:   52(float) Load 565(lod)
+            1016:    7(fvec4) ImageSampleExplicitLod 1013 1014 Lod ConstOffset 1015 709
+            1017:    7(fvec4) Load 1012(texel)
+            1018:    7(fvec4) FAdd 1017 1016
+                              Store 1012(texel) 1018
+            1019:         123 Load 125(s1D)
+            1020:    6(float) Load 135(f16c1)
+            1021:    6(float) Load 572(f16lod)
+            1022:    7(fvec4) ImageSampleExplicitLod 1019 1020 Lod ConstOffset 1021 709
+            1023:    7(fvec4) Load 1012(texel)
+            1024:    7(fvec4) FAdd 1023 1022
+                              Store 1012(texel) 1024
+            1025:         143 Load 145(s2D)
+            1026:   53(fvec2) Load 148(c2)
+            1027:   52(float) Load 565(lod)
+            1028:    7(fvec4) ImageSampleExplicitLod 1025 1026 Lod ConstOffset 1027 722
+            1029:    7(fvec4) Load 1012(texel)
+            1030:    7(fvec4) FAdd 1029 1028
+                              Store 1012(texel) 1030
+            1031:         143 Load 145(s2D)
+            1032:  154(fvec2) Load 156(f16c2)
+            1033:    6(float) Load 572(f16lod)
+            1034:    7(fvec4) ImageSampleExplicitLod 1031 1032 Lod ConstOffset 1033 722
+            1035:    7(fvec4) Load 1012(texel)
+            1036:    7(fvec4) FAdd 1035 1034
+                              Store 1012(texel) 1036
+            1037:         163 Load 165(s3D)
+            1038:  167(fvec3) Load 169(c3)
+            1039:   52(float) Load 565(lod)
+            1040:    7(fvec4) ImageSampleExplicitLod 1037 1038 Lod ConstOffset 1039 735
+            1041:    7(fvec4) Load 1012(texel)
+            1042:    7(fvec4) FAdd 1041 1040
+                              Store 1012(texel) 1042
+            1043:         163 Load 165(s3D)
+            1044:  175(fvec3) Load 177(f16c3)
+            1045:    6(float) Load 572(f16lod)
+            1046:    7(fvec4) ImageSampleExplicitLod 1043 1044 Lod ConstOffset 1045 735
+            1047:    7(fvec4) Load 1012(texel)
+            1048:    7(fvec4) FAdd 1047 1046
+                              Store 1012(texel) 1048
+            1049:         199 Load 201(s1DShadow)
+            1050:  167(fvec3) Load 169(c3)
+            1051:   52(float) Load 565(lod)
+            1052:   52(float) CompositeExtract 1050 2
+            1053:    6(float) ImageSampleDrefExplicitLod 1049 1050 1052 Lod ConstOffset 1051 709
+            1054:    208(ptr) AccessChain 1012(texel) 207
+            1055:    6(float) Load 1054
+            1056:    6(float) FAdd 1055 1053
+            1057:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1057 1056
+            1058:         199 Load 201(s1DShadow)
+            1059:  154(fvec2) Load 156(f16c2)
+            1060:   52(float) Load 215(compare)
+            1061:    6(float) Load 572(f16lod)
+            1062:    6(float) ImageSampleDrefExplicitLod 1058 1059 1060 Lod ConstOffset 1061 709
+            1063:    208(ptr) AccessChain 1012(texel) 207
+            1064:    6(float) Load 1063
+            1065:    6(float) FAdd 1064 1062
+            1066:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1066 1065
+            1067:         224 Load 226(s2DShadow)
+            1068:  167(fvec3) Load 169(c3)
+            1069:   52(float) Load 565(lod)
+            1070:   52(float) CompositeExtract 1068 2
+            1071:    6(float) ImageSampleDrefExplicitLod 1067 1068 1070 Lod ConstOffset 1069 722
+            1072:    208(ptr) AccessChain 1012(texel) 207
+            1073:    6(float) Load 1072
+            1074:    6(float) FAdd 1073 1071
+            1075:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1075 1074
+            1076:         224 Load 226(s2DShadow)
+            1077:  154(fvec2) Load 156(f16c2)
+            1078:   52(float) Load 215(compare)
+            1079:    6(float) Load 572(f16lod)
+            1080:    6(float) ImageSampleDrefExplicitLod 1076 1077 1078 Lod ConstOffset 1079 722
+            1081:    208(ptr) AccessChain 1012(texel) 207
+            1082:    6(float) Load 1081
+            1083:    6(float) FAdd 1082 1080
+            1084:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1084 1083
+            1085:         269 Load 271(s1DArray)
+            1086:   53(fvec2) Load 148(c2)
+            1087:   52(float) Load 565(lod)
+            1088:    7(fvec4) ImageSampleExplicitLod 1085 1086 Lod ConstOffset 1087 709
+            1089:    7(fvec4) Load 1012(texel)
+            1090:    7(fvec4) FAdd 1089 1088
+                              Store 1012(texel) 1090
+            1091:         269 Load 271(s1DArray)
+            1092:  154(fvec2) Load 156(f16c2)
+            1093:    6(float) Load 572(f16lod)
+            1094:    7(fvec4) ImageSampleExplicitLod 1091 1092 Lod ConstOffset 1093 709
+            1095:    7(fvec4) Load 1012(texel)
+            1096:    7(fvec4) FAdd 1095 1094
+                              Store 1012(texel) 1096
+            1097:         284 Load 286(s2DArray)
+            1098:  167(fvec3) Load 169(c3)
+            1099:   52(float) Load 565(lod)
+            1100:    7(fvec4) ImageSampleExplicitLod 1097 1098 Lod ConstOffset 1099 722
+            1101:    7(fvec4) Load 1012(texel)
+            1102:    7(fvec4) FAdd 1101 1100
+                              Store 1012(texel) 1102
+            1103:         284 Load 286(s2DArray)
+            1104:  175(fvec3) Load 177(f16c3)
+            1105:    6(float) Load 572(f16lod)
+            1106:    7(fvec4) ImageSampleExplicitLod 1103 1104 Lod ConstOffset 1105 722
+            1107:    7(fvec4) Load 1012(texel)
+            1108:    7(fvec4) FAdd 1107 1106
+                              Store 1012(texel) 1108
+            1109:         316 Load 318(s1DArrayShadow)
+            1110:  167(fvec3) Load 169(c3)
+            1111:   52(float) Load 565(lod)
+            1112:   52(float) CompositeExtract 1110 2
+            1113:    6(float) ImageSampleDrefExplicitLod 1109 1110 1112 Lod ConstOffset 1111 709
+            1114:    208(ptr) AccessChain 1012(texel) 207
+            1115:    6(float) Load 1114
+            1116:    6(float) FAdd 1115 1113
+            1117:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1117 1116
+            1118:         316 Load 318(s1DArrayShadow)
+            1119:  154(fvec2) Load 156(f16c2)
+            1120:   52(float) Load 215(compare)
+            1121:    6(float) Load 572(f16lod)
+            1122:    6(float) ImageSampleDrefExplicitLod 1118 1119 1120 Lod ConstOffset 1121 709
+            1123:    208(ptr) AccessChain 1012(texel) 207
+            1124:    6(float) Load 1123
+            1125:    6(float) FAdd 1124 1122
+            1126:    208(ptr) AccessChain 1012(texel) 207
+                              Store 1126 1125
+            1127:    7(fvec4) Load 1012(texel)
+                              ReturnValue 1127
+                              FunctionEnd
+21(testTextureProjLodOffset():    7(fvec4) Function None 8
+              22:             Label
+     1130(texel):     64(ptr) Variable Function
+                              Store 1130(texel) 121
+            1131:         123 Load 125(s1D)
+            1132:   53(fvec2) Load 148(c2)
+            1133:   52(float) Load 565(lod)
+            1134:    7(fvec4) ImageSampleProjExplicitLod 1131 1132 Lod ConstOffset 1133 709
+            1135:    7(fvec4) Load 1130(texel)
+            1136:    7(fvec4) FAdd 1135 1134
+                              Store 1130(texel) 1136
+            1137:         123 Load 125(s1D)
+            1138:  154(fvec2) Load 156(f16c2)
+            1139:    6(float) Load 572(f16lod)
+            1140:    7(fvec4) ImageSampleProjExplicitLod 1137 1138 Lod ConstOffset 1139 709
+            1141:    7(fvec4) Load 1130(texel)
+            1142:    7(fvec4) FAdd 1141 1140
+                              Store 1130(texel) 1142
+            1143:         123 Load 125(s1D)
+            1144:  249(fvec4) Load 251(c4)
+            1145:   52(float) Load 565(lod)
+            1146:   52(float) CompositeExtract 1144 3
+            1147:  249(fvec4) CompositeInsert 1146 1144 1
+            1148:    7(fvec4) ImageSampleProjExplicitLod 1143 1147 Lod ConstOffset 1145 709
+            1149:    7(fvec4) Load 1130(texel)
+            1150:    7(fvec4) FAdd 1149 1148
+                              Store 1130(texel) 1150
+            1151:         123 Load 125(s1D)
+            1152:    7(fvec4) Load 309(f16c4)
+            1153:    6(float) Load 572(f16lod)
+            1154:    6(float) CompositeExtract 1152 3
+            1155:    7(fvec4) CompositeInsert 1154 1152 1
+            1156:    7(fvec4) ImageSampleProjExplicitLod 1151 1155 Lod ConstOffset 1153 709
+            1157:    7(fvec4) Load 1130(texel)
+            1158:    7(fvec4) FAdd 1157 1156
+                              Store 1130(texel) 1158
+            1159:         143 Load 145(s2D)
+            1160:  167(fvec3) Load 169(c3)
+            1161:   52(float) Load 565(lod)
+            1162:    7(fvec4) ImageSampleProjExplicitLod 1159 1160 Lod ConstOffset 1161 722
+            1163:    7(fvec4) Load 1130(texel)
+            1164:    7(fvec4) FAdd 1163 1162
+                              Store 1130(texel) 1164
+            1165:         143 Load 145(s2D)
+            1166:  175(fvec3) Load 177(f16c3)
+            1167:    6(float) Load 572(f16lod)
+            1168:    7(fvec4) ImageSampleProjExplicitLod 1165 1166 Lod ConstOffset 1167 722
+            1169:    7(fvec4) Load 1130(texel)
+            1170:    7(fvec4) FAdd 1169 1168
+                              Store 1130(texel) 1170
+            1171:         143 Load 145(s2D)
+            1172:  249(fvec4) Load 251(c4)
+            1173:   52(float) Load 565(lod)
+            1174:   52(float) CompositeExtract 1172 3
+            1175:  249(fvec4) CompositeInsert 1174 1172 2
+            1176:    7(fvec4) ImageSampleProjExplicitLod 1171 1175 Lod ConstOffset 1173 722
+            1177:    7(fvec4) Load 1130(texel)
+            1178:    7(fvec4) FAdd 1177 1176
+                              Store 1130(texel) 1178
+            1179:         143 Load 145(s2D)
+            1180:    7(fvec4) Load 309(f16c4)
+            1181:    6(float) Load 572(f16lod)
+            1182:    6(float) CompositeExtract 1180 3
+            1183:    7(fvec4) CompositeInsert 1182 1180 2
+            1184:    7(fvec4) ImageSampleProjExplicitLod 1179 1183 Lod ConstOffset 1181 722
+            1185:    7(fvec4) Load 1130(texel)
+            1186:    7(fvec4) FAdd 1185 1184
+                              Store 1130(texel) 1186
+            1187:         163 Load 165(s3D)
+            1188:  249(fvec4) Load 251(c4)
+            1189:   52(float) Load 565(lod)
+            1190:    7(fvec4) ImageSampleProjExplicitLod 1187 1188 Lod ConstOffset 1189 735
+            1191:    7(fvec4) Load 1130(texel)
+            1192:    7(fvec4) FAdd 1191 1190
+                              Store 1130(texel) 1192
+            1193:         163 Load 165(s3D)
+            1194:    7(fvec4) Load 309(f16c4)
+            1195:    6(float) Load 572(f16lod)
+            1196:    7(fvec4) ImageSampleProjExplicitLod 1193 1194 Lod ConstOffset 1195 735
+            1197:    7(fvec4) Load 1130(texel)
+            1198:    7(fvec4) FAdd 1197 1196
+                              Store 1130(texel) 1198
+            1199:         199 Load 201(s1DShadow)
+            1200:  249(fvec4) Load 251(c4)
+            1201:   52(float) Load 565(lod)
+            1202:   52(float) CompositeExtract 1200 2
+            1203:   52(float) CompositeExtract 1200 3
+            1204:  249(fvec4) CompositeInsert 1203 1200 1
+            1205:    6(float) ImageSampleProjDrefExplicitLod 1199 1204 1202 Lod ConstOffset 1201 709
+            1206:    208(ptr) AccessChain 1130(texel) 207
+            1207:    6(float) Load 1206
+            1208:    6(float) FAdd 1207 1205
+            1209:    208(ptr) AccessChain 1130(texel) 207
+                              Store 1209 1208
+            1210:         199 Load 201(s1DShadow)
+            1211:  175(fvec3) Load 177(f16c3)
+            1212:   52(float) Load 215(compare)
+            1213:    6(float) Load 572(f16lod)
+            1214:    6(float) CompositeExtract 1211 2
+            1215:  175(fvec3) CompositeInsert 1214 1211 1
+            1216:    6(float) ImageSampleProjDrefExplicitLod 1210 1215 1212 Lod ConstOffset 1213 709
+            1217:    208(ptr) AccessChain 1130(texel) 207
+            1218:    6(float) Load 1217
+            1219:    6(float) FAdd 1218 1216
+            1220:    208(ptr) AccessChain 1130(texel) 207
+                              Store 1220 1219
+            1221:         224 Load 226(s2DShadow)
+            1222:  249(fvec4) Load 251(c4)
+            1223:   52(float) Load 565(lod)
+            1224:   52(float) CompositeExtract 1222 2
+            1225:   52(float) CompositeExtract 1222 3
+            1226:  249(fvec4) CompositeInsert 1225 1222 2
+            1227:    6(float) ImageSampleProjDrefExplicitLod 1221 1226 1224 Lod ConstOffset 1223 722
+            1228:    208(ptr) AccessChain 1130(texel) 207
+            1229:    6(float) Load 1228
+            1230:    6(float) FAdd 1229 1227
+            1231:    208(ptr) AccessChain 1130(texel) 207
+                              Store 1231 1230
+            1232:         224 Load 226(s2DShadow)
+            1233:  175(fvec3) Load 177(f16c3)
+            1234:   52(float) Load 215(compare)
+            1235:    6(float) Load 572(f16lod)
+            1236:    6(float) ImageSampleProjDrefExplicitLod 1232 1233 1234 Lod ConstOffset 1235 722
+            1237:    208(ptr) AccessChain 1130(texel) 207
+            1238:    6(float) Load 1237
+            1239:    6(float) FAdd 1238 1236
+            1240:    208(ptr) AccessChain 1130(texel) 207
+                              Store 1240 1239
+            1241:    7(fvec4) Load 1130(texel)
+                              ReturnValue 1241
+                              FunctionEnd
+23(testTexelFetch():    7(fvec4) Function None 8
+              24:             Label
+     1244(texel):     64(ptr) Variable Function
+                              Store 1244(texel) 121
+            1245:         123 Load 125(s1D)
+            1246:   52(float) Load 128(c1)
+            1247:     47(int) ConvertFToS 1246
+            1248:   52(float) Load 565(lod)
+            1249:     47(int) ConvertFToS 1248
+            1250:         122 Image 1245
+            1251:    7(fvec4) ImageFetch 1250 1247 Lod 1249
+            1252:    7(fvec4) Load 1244(texel)
+            1253:    7(fvec4) FAdd 1252 1251
+                              Store 1244(texel) 1253
+            1254:         143 Load 145(s2D)
+            1255:   53(fvec2) Load 148(c2)
+            1256:  721(ivec2) ConvertFToS 1255
+            1257:   52(float) Load 565(lod)
+            1258:     47(int) ConvertFToS 1257
+            1259:         142 Image 1254
+            1260:    7(fvec4) ImageFetch 1259 1256 Lod 1258
+            1261:    7(fvec4) Load 1244(texel)
+            1262:    7(fvec4) FAdd 1261 1260
+                              Store 1244(texel) 1262
+            1263:         163 Load 165(s3D)
+            1264:  167(fvec3) Load 169(c3)
+            1265:  734(ivec3) ConvertFToS 1264
+            1266:   52(float) Load 565(lod)
+            1267:     47(int) ConvertFToS 1266
+            1268:         162 Image 1263
+            1269:    7(fvec4) ImageFetch 1268 1265 Lod 1267
+            1270:    7(fvec4) Load 1244(texel)
+            1271:    7(fvec4) FAdd 1270 1269
+                              Store 1244(texel) 1271
+            1272:         357 Load 359(s2DRect)
+            1273:   53(fvec2) Load 148(c2)
+            1274:  721(ivec2) ConvertFToS 1273
+            1275:         356 Image 1272
+            1276:    7(fvec4) ImageFetch 1275 1274
+            1277:    7(fvec4) Load 1244(texel)
+            1278:    7(fvec4) FAdd 1277 1276
+                              Store 1244(texel) 1278
+            1279:         269 Load 271(s1DArray)
+            1280:   53(fvec2) Load 148(c2)
+            1281:  721(ivec2) ConvertFToS 1280
+            1282:   52(float) Load 565(lod)
+            1283:     47(int) ConvertFToS 1282
+            1284:         268 Image 1279
+            1285:    7(fvec4) ImageFetch 1284 1281 Lod 1283
+            1286:    7(fvec4) Load 1244(texel)
+            1287:    7(fvec4) FAdd 1286 1285
+                              Store 1244(texel) 1287
+            1288:         284 Load 286(s2DArray)
+            1289:  167(fvec3) Load 169(c3)
+            1290:  734(ivec3) ConvertFToS 1289
+            1291:   52(float) Load 565(lod)
+            1292:     47(int) ConvertFToS 1291
+            1293:         283 Image 1288
+            1294:    7(fvec4) ImageFetch 1293 1290 Lod 1292
+            1295:    7(fvec4) Load 1244(texel)
+            1296:    7(fvec4) FAdd 1295 1294
+                              Store 1244(texel) 1296
+            1301:        1298 Load 1300(sBuffer)
+            1302:   52(float) Load 128(c1)
+            1303:     47(int) ConvertFToS 1302
+            1304:        1297 Image 1301
+            1305:    7(fvec4) ImageFetch 1304 1303
+            1306:    7(fvec4) Load 1244(texel)
+            1307:    7(fvec4) FAdd 1306 1305
+                              Store 1244(texel) 1307
+            1312:        1309 Load 1311(s2DMS)
+            1313:   53(fvec2) Load 148(c2)
+            1314:  721(ivec2) ConvertFToS 1313
+            1315:        1308 Image 1312
+            1316:    7(fvec4) ImageFetch 1315 1314 Sample 709
+            1317:    7(fvec4) Load 1244(texel)
+            1318:    7(fvec4) FAdd 1317 1316
+                              Store 1244(texel) 1318
+            1323:        1320 Load 1322(s2DMSArray)
+            1324:  167(fvec3) Load 169(c3)
+            1325:  734(ivec3) ConvertFToS 1324
+            1327:        1319 Image 1323
+            1328:    7(fvec4) ImageFetch 1327 1325 Sample 1326
+            1329:    7(fvec4) Load 1244(texel)
+            1330:    7(fvec4) FAdd 1329 1328
+                              Store 1244(texel) 1330
+            1331:    7(fvec4) Load 1244(texel)
+                              ReturnValue 1331
+                              FunctionEnd
+25(testTexelFetchOffset():    7(fvec4) Function None 8
+              26:             Label
+     1334(texel):     64(ptr) Variable Function
+                              Store 1334(texel) 121
+            1335:         123 Load 125(s1D)
+            1336:   52(float) Load 128(c1)
+            1337:     47(int) ConvertFToS 1336
+            1338:   52(float) Load 565(lod)
+            1339:     47(int) ConvertFToS 1338
+            1340:         122 Image 1335
+            1341:    7(fvec4) ImageFetch 1340 1337 Lod ConstOffset 1339 709
+            1342:    7(fvec4) Load 1334(texel)
+            1343:    7(fvec4) FAdd 1342 1341
+                              Store 1334(texel) 1343
+            1344:         143 Load 145(s2D)
+            1345:   53(fvec2) Load 148(c2)
+            1346:  721(ivec2) ConvertFToS 1345
+            1347:   52(float) Load 565(lod)
+            1348:     47(int) ConvertFToS 1347
+            1349:         142 Image 1344
+            1350:    7(fvec4) ImageFetch 1349 1346 Lod ConstOffset 1348 722
+            1351:    7(fvec4) Load 1334(texel)
+            1352:    7(fvec4) FAdd 1351 1350
+                              Store 1334(texel) 1352
+            1353:         163 Load 165(s3D)
+            1354:  167(fvec3) Load 169(c3)
+            1355:  734(ivec3) ConvertFToS 1354
+            1356:   52(float) Load 565(lod)
+            1357:     47(int) ConvertFToS 1356
+            1358:         162 Image 1353
+            1359:    7(fvec4) ImageFetch 1358 1355 Lod ConstOffset 1357 735
+            1360:    7(fvec4) Load 1334(texel)
+            1361:    7(fvec4) FAdd 1360 1359
+                              Store 1334(texel) 1361
+            1362:         357 Load 359(s2DRect)
+            1363:   53(fvec2) Load 148(c2)
+            1364:  721(ivec2) ConvertFToS 1363
+            1365:         356 Image 1362
+            1366:    7(fvec4) ImageFetch 1365 1364 ConstOffset 722
+            1367:    7(fvec4) Load 1334(texel)
+            1368:    7(fvec4) FAdd 1367 1366
+                              Store 1334(texel) 1368
+            1369:         269 Load 271(s1DArray)
+            1370:   53(fvec2) Load 148(c2)
+            1371:  721(ivec2) ConvertFToS 1370
+            1372:   52(float) Load 565(lod)
+            1373:     47(int) ConvertFToS 1372
+            1374:         268 Image 1369
+            1375:    7(fvec4) ImageFetch 1374 1371 Lod ConstOffset 1373 709
+            1376:    7(fvec4) Load 1334(texel)
+            1377:    7(fvec4) FAdd 1376 1375
+                              Store 1334(texel) 1377
+            1378:         284 Load 286(s2DArray)
+            1379:  167(fvec3) Load 169(c3)
+            1380:  734(ivec3) ConvertFToS 1379
+            1381:   52(float) Load 565(lod)
+            1382:     47(int) ConvertFToS 1381
+            1383:         283 Image 1378
+            1384:    7(fvec4) ImageFetch 1383 1380 Lod ConstOffset 1382 722
+            1385:    7(fvec4) Load 1334(texel)
+            1386:    7(fvec4) FAdd 1385 1384
+                              Store 1334(texel) 1386
+            1387:    7(fvec4) Load 1334(texel)
+                              ReturnValue 1387
+                              FunctionEnd
+27(testTextureGrad():    7(fvec4) Function None 8
+              28:             Label
+     1390(texel):     64(ptr) Variable Function
+                              Store 1390(texel) 121
+            1391:         123 Load 125(s1D)
+            1392:   52(float) Load 128(c1)
+            1394:   52(float) Load 1393(dPdxy1)
+            1395:   52(float) Load 1393(dPdxy1)
+            1396:    7(fvec4) ImageSampleExplicitLod 1391 1392 Grad 1394 1395
+            1397:    7(fvec4) Load 1390(texel)
+            1398:    7(fvec4) FAdd 1397 1396
+                              Store 1390(texel) 1398
+            1399:         123 Load 125(s1D)
+            1400:    6(float) Load 135(f16c1)
+            1402:    6(float) Load 1401(f16dPdxy1)
+            1403:    6(float) Load 1401(f16dPdxy1)
+            1404:    7(fvec4) ImageSampleExplicitLod 1399 1400 Grad 1402 1403
+            1405:    7(fvec4) Load 1390(texel)
+            1406:    7(fvec4) FAdd 1405 1404
+                              Store 1390(texel) 1406
+            1407:         143 Load 145(s2D)
+            1408:   53(fvec2) Load 148(c2)
+            1410:   53(fvec2) Load 1409(dPdxy2)
+            1411:   53(fvec2) Load 1409(dPdxy2)
+            1412:    7(fvec4) ImageSampleExplicitLod 1407 1408 Grad 1410 1411
+            1413:    7(fvec4) Load 1390(texel)
+            1414:    7(fvec4) FAdd 1413 1412
+                              Store 1390(texel) 1414
+            1415:         143 Load 145(s2D)
+            1416:  154(fvec2) Load 156(f16c2)
+            1418:  154(fvec2) Load 1417(f16dPdxy2)
+            1419:  154(fvec2) Load 1417(f16dPdxy2)
+            1420:    7(fvec4) ImageSampleExplicitLod 1415 1416 Grad 1418 1419
+            1421:    7(fvec4) Load 1390(texel)
+            1422:    7(fvec4) FAdd 1421 1420
+                              Store 1390(texel) 1422
+            1423:         163 Load 165(s3D)
+            1424:  167(fvec3) Load 169(c3)
+            1426:  167(fvec3) Load 1425(dPdxy3)
+            1427:  167(fvec3) Load 1425(dPdxy3)
+            1428:    7(fvec4) ImageSampleExplicitLod 1423 1424 Grad 1426 1427
+            1429:    7(fvec4) Load 1390(texel)
+            1430:    7(fvec4) FAdd 1429 1428
+                              Store 1390(texel) 1430
+            1431:         163 Load 165(s3D)
+            1432:  175(fvec3) Load 177(f16c3)
+            1434:  175(fvec3) Load 1433(f16dPdxy3)
+            1435:  175(fvec3) Load 1433(f16dPdxy3)
+            1436:    7(fvec4) ImageSampleExplicitLod 1431 1432 Grad 1434 1435
+            1437:    7(fvec4) Load 1390(texel)
+            1438:    7(fvec4) FAdd 1437 1436
+                              Store 1390(texel) 1438
+            1439:         184 Load 186(sCube)
+            1440:  167(fvec3) Load 169(c3)
+            1441:  167(fvec3) Load 1425(dPdxy3)
+            1442:  167(fvec3) Load 1425(dPdxy3)
+            1443:    7(fvec4) ImageSampleExplicitLod 1439 1440 Grad 1441 1442
+            1444:    7(fvec4) Load 1390(texel)
+            1445:    7(fvec4) FAdd 1444 1443
+                              Store 1390(texel) 1445
+            1446:         184 Load 186(sCube)
+            1447:  175(fvec3) Load 177(f16c3)
+            1448:  175(fvec3) Load 1433(f16dPdxy3)
+            1449:  175(fvec3) Load 1433(f16dPdxy3)
+            1450:    7(fvec4) ImageSampleExplicitLod 1446 1447 Grad 1448 1449
+            1451:    7(fvec4) Load 1390(texel)
+            1452:    7(fvec4) FAdd 1451 1450
+                              Store 1390(texel) 1452
+            1453:         357 Load 359(s2DRect)
+            1454:   53(fvec2) Load 148(c2)
+            1455:   53(fvec2) Load 1409(dPdxy2)
+            1456:   53(fvec2) Load 1409(dPdxy2)
+            1457:    7(fvec4) ImageSampleExplicitLod 1453 1454 Grad 1455 1456
+            1458:    7(fvec4) Load 1390(texel)
+            1459:    7(fvec4) FAdd 1458 1457
+                              Store 1390(texel) 1459
+            1460:         357 Load 359(s2DRect)
+            1461:  154(fvec2) Load 156(f16c2)
+            1462:  154(fvec2) Load 1417(f16dPdxy2)
+            1463:  154(fvec2) Load 1417(f16dPdxy2)
+            1464:    7(fvec4) ImageSampleExplicitLod 1460 1461 Grad 1462 1463
+            1465:    7(fvec4) Load 1390(texel)
+            1466:    7(fvec4) FAdd 1465 1464
+                              Store 1390(texel) 1466
+            1467:         371 Load 373(s2DRectShadow)
+            1468:  167(fvec3) Load 169(c3)
+            1469:   53(fvec2) Load 1409(dPdxy2)
+            1470:   53(fvec2) Load 1409(dPdxy2)
+            1471:   52(float) CompositeExtract 1468 2
+            1472:    6(float) ImageSampleDrefExplicitLod 1467 1468 1471 Grad 1469 1470
+            1473:    208(ptr) AccessChain 1390(texel) 207
+            1474:    6(float) Load 1473
+            1475:    6(float) FAdd 1474 1472
+            1476:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1476 1475
+            1477:         371 Load 373(s2DRectShadow)
+            1478:  154(fvec2) Load 156(f16c2)
+            1479:   52(float) Load 215(compare)
+            1480:  154(fvec2) Load 1417(f16dPdxy2)
+            1481:  154(fvec2) Load 1417(f16dPdxy2)
+            1482:    6(float) ImageSampleDrefExplicitLod 1477 1478 1479 Grad 1480 1481
+            1483:    208(ptr) AccessChain 1390(texel) 207
+            1484:    6(float) Load 1483
+            1485:    6(float) FAdd 1484 1482
+            1486:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1486 1485
+            1487:         199 Load 201(s1DShadow)
+            1488:  167(fvec3) Load 169(c3)
+            1489:   52(float) Load 1393(dPdxy1)
+            1490:   52(float) Load 1393(dPdxy1)
+            1491:   52(float) CompositeExtract 1488 2
+            1492:    6(float) ImageSampleDrefExplicitLod 1487 1488 1491 Grad 1489 1490
+            1493:    208(ptr) AccessChain 1390(texel) 207
+            1494:    6(float) Load 1493
+            1495:    6(float) FAdd 1494 1492
+            1496:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1496 1495
+            1497:         199 Load 201(s1DShadow)
+            1498:  154(fvec2) Load 156(f16c2)
+            1499:   52(float) Load 215(compare)
+            1500:    6(float) Load 1401(f16dPdxy1)
+            1501:    6(float) Load 1401(f16dPdxy1)
+            1502:    6(float) ImageSampleDrefExplicitLod 1497 1498 1499 Grad 1500 1501
+            1503:    208(ptr) AccessChain 1390(texel) 207
+            1504:    6(float) Load 1503
+            1505:    6(float) FAdd 1504 1502
+            1506:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1506 1505
+            1507:         224 Load 226(s2DShadow)
+            1508:  167(fvec3) Load 169(c3)
+            1509:   53(fvec2) Load 1409(dPdxy2)
+            1510:   53(fvec2) Load 1409(dPdxy2)
+            1511:   52(float) CompositeExtract 1508 2
+            1512:    6(float) ImageSampleDrefExplicitLod 1507 1508 1511 Grad 1509 1510
+            1513:    208(ptr) AccessChain 1390(texel) 207
+            1514:    6(float) Load 1513
+            1515:    6(float) FAdd 1514 1512
+            1516:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1516 1515
+            1517:         224 Load 226(s2DShadow)
+            1518:  154(fvec2) Load 156(f16c2)
+            1519:   52(float) Load 215(compare)
+            1520:  154(fvec2) Load 1417(f16dPdxy2)
+            1521:  154(fvec2) Load 1417(f16dPdxy2)
+            1522:    6(float) ImageSampleDrefExplicitLod 1517 1518 1519 Grad 1520 1521
+            1523:    208(ptr) AccessChain 1390(texel) 207
+            1524:    6(float) Load 1523
+            1525:    6(float) FAdd 1524 1522
+            1526:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1526 1525
+            1527:         245 Load 247(sCubeShadow)
+            1528:  249(fvec4) Load 251(c4)
+            1529:  167(fvec3) Load 1425(dPdxy3)
+            1530:  167(fvec3) Load 1425(dPdxy3)
+            1531:   52(float) CompositeExtract 1528 3
+            1532:    6(float) ImageSampleDrefExplicitLod 1527 1528 1531 Grad 1529 1530
+            1533:    208(ptr) AccessChain 1390(texel) 207
+            1534:    6(float) Load 1533
+            1535:    6(float) FAdd 1534 1532
+            1536:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1536 1535
+            1537:         245 Load 247(sCubeShadow)
+            1538:  175(fvec3) Load 177(f16c3)
+            1539:   52(float) Load 215(compare)
+            1540:  175(fvec3) Load 1433(f16dPdxy3)
+            1541:  175(fvec3) Load 1433(f16dPdxy3)
+            1542:    6(float) ImageSampleDrefExplicitLod 1537 1538 1539 Grad 1540 1541
+            1543:    208(ptr) AccessChain 1390(texel) 207
+            1544:    6(float) Load 1543
+            1545:    6(float) FAdd 1544 1542
+            1546:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1546 1545
+            1547:         269 Load 271(s1DArray)
+            1548:   53(fvec2) Load 148(c2)
+            1549:   52(float) Load 1393(dPdxy1)
+            1550:   52(float) Load 1393(dPdxy1)
+            1551:    7(fvec4) ImageSampleExplicitLod 1547 1548 Grad 1549 1550
+            1552:    7(fvec4) Load 1390(texel)
+            1553:    7(fvec4) FAdd 1552 1551
+                              Store 1390(texel) 1553
+            1554:         269 Load 271(s1DArray)
+            1555:  154(fvec2) Load 156(f16c2)
+            1556:    6(float) Load 1401(f16dPdxy1)
+            1557:    6(float) Load 1401(f16dPdxy1)
+            1558:    7(fvec4) ImageSampleExplicitLod 1554 1555 Grad 1556 1557
+            1559:    7(fvec4) Load 1390(texel)
+            1560:    7(fvec4) FAdd 1559 1558
+                              Store 1390(texel) 1560
+            1561:         284 Load 286(s2DArray)
+            1562:  167(fvec3) Load 169(c3)
+            1563:   53(fvec2) Load 1409(dPdxy2)
+            1564:   53(fvec2) Load 1409(dPdxy2)
+            1565:    7(fvec4) ImageSampleExplicitLod 1561 1562 Grad 1563 1564
+            1566:    7(fvec4) Load 1390(texel)
+            1567:    7(fvec4) FAdd 1566 1565
+                              Store 1390(texel) 1567
+            1568:         284 Load 286(s2DArray)
+            1569:  175(fvec3) Load 177(f16c3)
+            1570:  154(fvec2) Load 1417(f16dPdxy2)
+            1571:  154(fvec2) Load 1417(f16dPdxy2)
+            1572:    7(fvec4) ImageSampleExplicitLod 1568 1569 Grad 1570 1571
+            1573:    7(fvec4) Load 1390(texel)
+            1574:    7(fvec4) FAdd 1573 1572
+                              Store 1390(texel) 1574
+            1575:         316 Load 318(s1DArrayShadow)
+            1576:  167(fvec3) Load 169(c3)
+            1577:   52(float) Load 1393(dPdxy1)
+            1578:   52(float) Load 1393(dPdxy1)
+            1579:   52(float) CompositeExtract 1576 2
+            1580:    6(float) ImageSampleDrefExplicitLod 1575 1576 1579 Grad 1577 1578
+            1581:    208(ptr) AccessChain 1390(texel) 207
+            1582:    6(float) Load 1581
+            1583:    6(float) FAdd 1582 1580
+            1584:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1584 1583
+            1585:         316 Load 318(s1DArrayShadow)
+            1586:  154(fvec2) Load 156(f16c2)
+            1587:   52(float) Load 215(compare)
+            1588:    6(float) Load 1401(f16dPdxy1)
+            1589:    6(float) Load 1401(f16dPdxy1)
+            1590:    6(float) ImageSampleDrefExplicitLod 1585 1586 1587 Grad 1588 1589
+            1591:    208(ptr) AccessChain 1390(texel) 207
+            1592:    6(float) Load 1591
+            1593:    6(float) FAdd 1592 1590
+            1594:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1594 1593
+            1595:         337 Load 339(s2DArrayShadow)
+            1596:  249(fvec4) Load 251(c4)
+            1597:   53(fvec2) Load 1409(dPdxy2)
+            1598:   53(fvec2) Load 1409(dPdxy2)
+            1599:   52(float) CompositeExtract 1596 3
+            1600:    6(float) ImageSampleDrefExplicitLod 1595 1596 1599 Grad 1597 1598
+            1601:    208(ptr) AccessChain 1390(texel) 207
+            1602:    6(float) Load 1601
+            1603:    6(float) FAdd 1602 1600
+            1604:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1604 1603
+            1605:         337 Load 339(s2DArrayShadow)
+            1606:  175(fvec3) Load 177(f16c3)
+            1607:   52(float) Load 215(compare)
+            1608:  154(fvec2) Load 1417(f16dPdxy2)
+            1609:  154(fvec2) Load 1417(f16dPdxy2)
+            1610:    6(float) ImageSampleDrefExplicitLod 1605 1606 1607 Grad 1608 1609
+            1611:    208(ptr) AccessChain 1390(texel) 207
+            1612:    6(float) Load 1611
+            1613:    6(float) FAdd 1612 1610
+            1614:    208(ptr) AccessChain 1390(texel) 207
+                              Store 1614 1613
+            1615:         299 Load 301(sCubeArray)
+            1616:  249(fvec4) Load 251(c4)
+            1617:  167(fvec3) Load 1425(dPdxy3)
+            1618:  167(fvec3) Load 1425(dPdxy3)
+            1619:    7(fvec4) ImageSampleExplicitLod 1615 1616 Grad 1617 1618
+            1620:    7(fvec4) Load 1390(texel)
+            1621:    7(fvec4) FAdd 1620 1619
+                              Store 1390(texel) 1621
+            1622:         299 Load 301(sCubeArray)
+            1623:    7(fvec4) Load 309(f16c4)
+            1624:  175(fvec3) Load 1433(f16dPdxy3)
+            1625:  175(fvec3) Load 1433(f16dPdxy3)
+            1626:    7(fvec4) ImageSampleExplicitLod 1622 1623 Grad 1624 1625
+            1627:    7(fvec4) Load 1390(texel)
+            1628:    7(fvec4) FAdd 1627 1626
+                              Store 1390(texel) 1628
+            1629:    7(fvec4) Load 1390(texel)
+                              ReturnValue 1629
+                              FunctionEnd
+29(testTextureGradOffset():    7(fvec4) Function None 8
+              30:             Label
+     1632(texel):     64(ptr) Variable Function
+                              Store 1632(texel) 121
+            1633:         123 Load 125(s1D)
+            1634:   52(float) Load 128(c1)
+            1635:   52(float) Load 1393(dPdxy1)
+            1636:   52(float) Load 1393(dPdxy1)
+            1637:    7(fvec4) ImageSampleExplicitLod 1633 1634 Grad ConstOffset 1635 1636 709
+            1638:    7(fvec4) Load 1632(texel)
+            1639:    7(fvec4) FAdd 1638 1637
+                              Store 1632(texel) 1639
+            1640:         123 Load 125(s1D)
+            1641:    6(float) Load 135(f16c1)
+            1642:    6(float) Load 1401(f16dPdxy1)
+            1643:    6(float) Load 1401(f16dPdxy1)
+            1644:    7(fvec4) ImageSampleExplicitLod 1640 1641 Grad ConstOffset 1642 1643 709
+            1645:    7(fvec4) Load 1632(texel)
+            1646:    7(fvec4) FAdd 1645 1644
+                              Store 1632(texel) 1646
+            1647:         143 Load 145(s2D)
+            1648:   53(fvec2) Load 148(c2)
+            1649:   53(fvec2) Load 1409(dPdxy2)
+            1650:   53(fvec2) Load 1409(dPdxy2)
+            1651:    7(fvec4) ImageSampleExplicitLod 1647 1648 Grad ConstOffset 1649 1650 722
+            1652:    7(fvec4) Load 1632(texel)
+            1653:    7(fvec4) FAdd 1652 1651
+                              Store 1632(texel) 1653
+            1654:         143 Load 145(s2D)
+            1655:  154(fvec2) Load 156(f16c2)
+            1656:  154(fvec2) Load 1417(f16dPdxy2)
+            1657:  154(fvec2) Load 1417(f16dPdxy2)
+            1658:    7(fvec4) ImageSampleExplicitLod 1654 1655 Grad ConstOffset 1656 1657 722
+            1659:    7(fvec4) Load 1632(texel)
+            1660:    7(fvec4) FAdd 1659 1658
+                              Store 1632(texel) 1660
+            1661:         163 Load 165(s3D)
+            1662:  167(fvec3) Load 169(c3)
+            1663:  167(fvec3) Load 1425(dPdxy3)
+            1664:  167(fvec3) Load 1425(dPdxy3)
+            1665:    7(fvec4) ImageSampleExplicitLod 1661 1662 Grad ConstOffset 1663 1664 735
+            1666:    7(fvec4) Load 1632(texel)
+            1667:    7(fvec4) FAdd 1666 1665
+                              Store 1632(texel) 1667
+            1668:         163 Load 165(s3D)
+            1669:  175(fvec3) Load 177(f16c3)
+            1670:  175(fvec3) Load 1433(f16dPdxy3)
+            1671:  175(fvec3) Load 1433(f16dPdxy3)
+            1672:    7(fvec4) ImageSampleExplicitLod 1668 1669 Grad ConstOffset 1670 1671 735
+            1673:    7(fvec4) Load 1632(texel)
+            1674:    7(fvec4) FAdd 1673 1672
+                              Store 1632(texel) 1674
+            1675:         357 Load 359(s2DRect)
+            1676:   53(fvec2) Load 148(c2)
+            1677:   53(fvec2) Load 1409(dPdxy2)
+            1678:   53(fvec2) Load 1409(dPdxy2)
+            1679:    7(fvec4) ImageSampleExplicitLod 1675 1676 Grad ConstOffset 1677 1678 722
+            1680:    7(fvec4) Load 1632(texel)
+            1681:    7(fvec4) FAdd 1680 1679
+                              Store 1632(texel) 1681
+            1682:         357 Load 359(s2DRect)
+            1683:  154(fvec2) Load 156(f16c2)
+            1684:  154(fvec2) Load 1417(f16dPdxy2)
+            1685:  154(fvec2) Load 1417(f16dPdxy2)
+            1686:    7(fvec4) ImageSampleExplicitLod 1682 1683 Grad ConstOffset 1684 1685 722
+            1687:    7(fvec4) Load 1632(texel)
+            1688:    7(fvec4) FAdd 1687 1686
+                              Store 1632(texel) 1688
+            1689:         371 Load 373(s2DRectShadow)
+            1690:  167(fvec3) Load 169(c3)
+            1691:   53(fvec2) Load 1409(dPdxy2)
+            1692:   53(fvec2) Load 1409(dPdxy2)
+            1693:   52(float) CompositeExtract 1690 2
+            1694:    6(float) ImageSampleDrefExplicitLod 1689 1690 1693 Grad ConstOffset 1691 1692 722
+            1695:    208(ptr) AccessChain 1632(texel) 207
+            1696:    6(float) Load 1695
+            1697:    6(float) FAdd 1696 1694
+            1698:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1698 1697
+            1699:         371 Load 373(s2DRectShadow)
+            1700:  154(fvec2) Load 156(f16c2)
+            1701:   52(float) Load 215(compare)
+            1702:  154(fvec2) Load 1417(f16dPdxy2)
+            1703:  154(fvec2) Load 1417(f16dPdxy2)
+            1704:    6(float) ImageSampleDrefExplicitLod 1699 1700 1701 Grad ConstOffset 1702 1703 722
+            1705:    208(ptr) AccessChain 1632(texel) 207
+            1706:    6(float) Load 1705
+            1707:    6(float) FAdd 1706 1704
+            1708:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1708 1707
+            1709:         199 Load 201(s1DShadow)
+            1710:  167(fvec3) Load 169(c3)
+            1711:   52(float) Load 1393(dPdxy1)
+            1712:   52(float) Load 1393(dPdxy1)
+            1713:   52(float) CompositeExtract 1710 2
+            1714:    6(float) ImageSampleDrefExplicitLod 1709 1710 1713 Grad ConstOffset 1711 1712 709
+            1715:    208(ptr) AccessChain 1632(texel) 207
+            1716:    6(float) Load 1715
+            1717:    6(float) FAdd 1716 1714
+            1718:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1718 1717
+            1719:         199 Load 201(s1DShadow)
+            1720:  154(fvec2) Load 156(f16c2)
+            1721:   52(float) Load 215(compare)
+            1722:    6(float) Load 1401(f16dPdxy1)
+            1723:    6(float) Load 1401(f16dPdxy1)
+            1724:    6(float) ImageSampleDrefExplicitLod 1719 1720 1721 Grad ConstOffset 1722 1723 709
+            1725:    208(ptr) AccessChain 1632(texel) 207
+            1726:    6(float) Load 1725
+            1727:    6(float) FAdd 1726 1724
+            1728:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1728 1727
+            1729:         224 Load 226(s2DShadow)
+            1730:  167(fvec3) Load 169(c3)
+            1731:   53(fvec2) Load 1409(dPdxy2)
+            1732:   53(fvec2) Load 1409(dPdxy2)
+            1733:   52(float) CompositeExtract 1730 2
+            1734:    6(float) ImageSampleDrefExplicitLod 1729 1730 1733 Grad ConstOffset 1731 1732 722
+            1735:    208(ptr) AccessChain 1632(texel) 207
+            1736:    6(float) Load 1735
+            1737:    6(float) FAdd 1736 1734
+            1738:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1738 1737
+            1739:         224 Load 226(s2DShadow)
+            1740:  154(fvec2) Load 156(f16c2)
+            1741:   52(float) Load 215(compare)
+            1742:  154(fvec2) Load 1417(f16dPdxy2)
+            1743:  154(fvec2) Load 1417(f16dPdxy2)
+            1744:    6(float) ImageSampleDrefExplicitLod 1739 1740 1741 Grad ConstOffset 1742 1743 722
+            1745:    208(ptr) AccessChain 1632(texel) 207
+            1746:    6(float) Load 1745
+            1747:    6(float) FAdd 1746 1744
+            1748:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1748 1747
+            1749:         269 Load 271(s1DArray)
+            1750:   53(fvec2) Load 148(c2)
+            1751:   52(float) Load 1393(dPdxy1)
+            1752:   52(float) Load 1393(dPdxy1)
+            1753:    7(fvec4) ImageSampleExplicitLod 1749 1750 Grad ConstOffset 1751 1752 709
+            1754:    7(fvec4) Load 1632(texel)
+            1755:    7(fvec4) FAdd 1754 1753
+                              Store 1632(texel) 1755
+            1756:         269 Load 271(s1DArray)
+            1757:  154(fvec2) Load 156(f16c2)
+            1758:    6(float) Load 1401(f16dPdxy1)
+            1759:    6(float) Load 1401(f16dPdxy1)
+            1760:    7(fvec4) ImageSampleExplicitLod 1756 1757 Grad ConstOffset 1758 1759 709
+            1761:    7(fvec4) Load 1632(texel)
+            1762:    7(fvec4) FAdd 1761 1760
+                              Store 1632(texel) 1762
+            1763:         284 Load 286(s2DArray)
+            1764:  167(fvec3) Load 169(c3)
+            1765:   53(fvec2) Load 1409(dPdxy2)
+            1766:   53(fvec2) Load 1409(dPdxy2)
+            1767:    7(fvec4) ImageSampleExplicitLod 1763 1764 Grad ConstOffset 1765 1766 722
+            1768:    7(fvec4) Load 1632(texel)
+            1769:    7(fvec4) FAdd 1768 1767
+                              Store 1632(texel) 1769
+            1770:         284 Load 286(s2DArray)
+            1771:  175(fvec3) Load 177(f16c3)
+            1772:  154(fvec2) Load 1417(f16dPdxy2)
+            1773:  154(fvec2) Load 1417(f16dPdxy2)
+            1774:    7(fvec4) ImageSampleExplicitLod 1770 1771 Grad ConstOffset 1772 1773 722
+            1775:    7(fvec4) Load 1632(texel)
+            1776:    7(fvec4) FAdd 1775 1774
+                              Store 1632(texel) 1776
+            1777:         316 Load 318(s1DArrayShadow)
+            1778:  167(fvec3) Load 169(c3)
+            1779:   52(float) Load 1393(dPdxy1)
+            1780:   52(float) Load 1393(dPdxy1)
+            1781:   52(float) CompositeExtract 1778 2
+            1782:    6(float) ImageSampleDrefExplicitLod 1777 1778 1781 Grad ConstOffset 1779 1780 709
+            1783:    208(ptr) AccessChain 1632(texel) 207
+            1784:    6(float) Load 1783
+            1785:    6(float) FAdd 1784 1782
+            1786:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1786 1785
+            1787:         316 Load 318(s1DArrayShadow)
+            1788:  154(fvec2) Load 156(f16c2)
+            1789:   52(float) Load 215(compare)
+            1790:    6(float) Load 1401(f16dPdxy1)
+            1791:    6(float) Load 1401(f16dPdxy1)
+            1792:    6(float) ImageSampleDrefExplicitLod 1787 1788 1789 Grad ConstOffset 1790 1791 709
+            1793:    208(ptr) AccessChain 1632(texel) 207
+            1794:    6(float) Load 1793
+            1795:    6(float) FAdd 1794 1792
+            1796:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1796 1795
+            1797:         337 Load 339(s2DArrayShadow)
+            1798:  249(fvec4) Load 251(c4)
+            1799:   53(fvec2) Load 1409(dPdxy2)
+            1800:   53(fvec2) Load 1409(dPdxy2)
+            1801:   52(float) CompositeExtract 1798 3
+            1802:    6(float) ImageSampleDrefExplicitLod 1797 1798 1801 Grad ConstOffset 1799 1800 722
+            1803:    208(ptr) AccessChain 1632(texel) 207
+            1804:    6(float) Load 1803
+            1805:    6(float) FAdd 1804 1802
+            1806:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1806 1805
+            1807:         337 Load 339(s2DArrayShadow)
+            1808:  175(fvec3) Load 177(f16c3)
+            1809:   52(float) Load 215(compare)
+            1810:  154(fvec2) Load 1417(f16dPdxy2)
+            1811:  154(fvec2) Load 1417(f16dPdxy2)
+            1812:    6(float) ImageSampleDrefExplicitLod 1807 1808 1809 Grad ConstOffset 1810 1811 722
+            1813:    208(ptr) AccessChain 1632(texel) 207
+            1814:    6(float) Load 1813
+            1815:    6(float) FAdd 1814 1812
+            1816:    208(ptr) AccessChain 1632(texel) 207
+                              Store 1816 1815
+            1817:    7(fvec4) Load 1632(texel)
+                              ReturnValue 1817
+                              FunctionEnd
+31(testTextureProjGrad():    7(fvec4) Function None 8
+              32:             Label
+     1820(texel):     64(ptr) Variable Function
+                              Store 1820(texel) 121
+            1821:         123 Load 125(s1D)
+            1822:   53(fvec2) Load 148(c2)
+            1823:   52(float) Load 1393(dPdxy1)
+            1824:   52(float) Load 1393(dPdxy1)
+            1825:    7(fvec4) ImageSampleProjExplicitLod 1821 1822 Grad 1823 1824
+            1826:    7(fvec4) Load 1820(texel)
+            1827:    7(fvec4) FAdd 1826 1825
+                              Store 1820(texel) 1827
+            1828:         123 Load 125(s1D)
+            1829:  154(fvec2) Load 156(f16c2)
+            1830:    6(float) Load 1401(f16dPdxy1)
+            1831:    6(float) Load 1401(f16dPdxy1)
+            1832:    7(fvec4) ImageSampleProjExplicitLod 1828 1829 Grad 1830 1831
+            1833:    7(fvec4) Load 1820(texel)
+            1834:    7(fvec4) FAdd 1833 1832
+                              Store 1820(texel) 1834
+            1835:         123 Load 125(s1D)
+            1836:  249(fvec4) Load 251(c4)
+            1837:   52(float) Load 1393(dPdxy1)
+            1838:   52(float) Load 1393(dPdxy1)
+            1839:   52(float) CompositeExtract 1836 3
+            1840:  249(fvec4) CompositeInsert 1839 1836 1
+            1841:    7(fvec4) ImageSampleProjExplicitLod 1835 1840 Grad 1837 1838
+            1842:    7(fvec4) Load 1820(texel)
+            1843:    7(fvec4) FAdd 1842 1841
+                              Store 1820(texel) 1843
+            1844:         123 Load 125(s1D)
+            1845:    7(fvec4) Load 309(f16c4)
+            1846:    6(float) Load 1401(f16dPdxy1)
+            1847:    6(float) Load 1401(f16dPdxy1)
+            1848:    6(float) CompositeExtract 1845 3
+            1849:    7(fvec4) CompositeInsert 1848 1845 1
+            1850:    7(fvec4) ImageSampleProjExplicitLod 1844 1849 Grad 1846 1847
+            1851:    7(fvec4) Load 1820(texel)
+            1852:    7(fvec4) FAdd 1851 1850
+                              Store 1820(texel) 1852
+            1853:         143 Load 145(s2D)
+            1854:  167(fvec3) Load 169(c3)
+            1855:   53(fvec2) Load 1409(dPdxy2)
+            1856:   53(fvec2) Load 1409(dPdxy2)
+            1857:    7(fvec4) ImageSampleProjExplicitLod 1853 1854 Grad 1855 1856
+            1858:    7(fvec4) Load 1820(texel)
+            1859:    7(fvec4) FAdd 1858 1857
+                              Store 1820(texel) 1859
+            1860:         143 Load 145(s2D)
+            1861:  175(fvec3) Load 177(f16c3)
+            1862:  154(fvec2) Load 1417(f16dPdxy2)
+            1863:  154(fvec2) Load 1417(f16dPdxy2)
+            1864:    7(fvec4) ImageSampleProjExplicitLod 1860 1861 Grad 1862 1863
+            1865:    7(fvec4) Load 1820(texel)
+            1866:    7(fvec4) FAdd 1865 1864
+                              Store 1820(texel) 1866
+            1867:         143 Load 145(s2D)
+            1868:  249(fvec4) Load 251(c4)
+            1869:   53(fvec2) Load 1409(dPdxy2)
+            1870:   53(fvec2) Load 1409(dPdxy2)
+            1871:   52(float) CompositeExtract 1868 3
+            1872:  249(fvec4) CompositeInsert 1871 1868 2
+            1873:    7(fvec4) ImageSampleProjExplicitLod 1867 1872 Grad 1869 1870
+            1874:    7(fvec4) Load 1820(texel)
+            1875:    7(fvec4) FAdd 1874 1873
+                              Store 1820(texel) 1875
+            1876:         143 Load 145(s2D)
+            1877:    7(fvec4) Load 309(f16c4)
+            1878:  154(fvec2) Load 1417(f16dPdxy2)
+            1879:  154(fvec2) Load 1417(f16dPdxy2)
+            1880:    6(float) CompositeExtract 1877 3
+            1881:    7(fvec4) CompositeInsert 1880 1877 2
+            1882:    7(fvec4) ImageSampleProjExplicitLod 1876 1881 Grad 1878 1879
+            1883:    7(fvec4) Load 1820(texel)
+            1884:    7(fvec4) FAdd 1883 1882
+                              Store 1820(texel) 1884
+            1885:         163 Load 165(s3D)
+            1886:  249(fvec4) Load 251(c4)
+            1887:  167(fvec3) Load 1425(dPdxy3)
+            1888:  167(fvec3) Load 1425(dPdxy3)
+            1889:    7(fvec4) ImageSampleProjExplicitLod 1885 1886 Grad 1887 1888
+            1890:    7(fvec4) Load 1820(texel)
+            1891:    7(fvec4) FAdd 1890 1889
+                              Store 1820(texel) 1891
+            1892:         163 Load 165(s3D)
+            1893:    7(fvec4) Load 309(f16c4)
+            1894:  175(fvec3) Load 1433(f16dPdxy3)
+            1895:  175(fvec3) Load 1433(f16dPdxy3)
+            1896:    7(fvec4) ImageSampleProjExplicitLod 1892 1893 Grad 1894 1895
+            1897:    7(fvec4) Load 1820(texel)
+            1898:    7(fvec4) FAdd 1897 1896
+                              Store 1820(texel) 1898
+            1899:         357 Load 359(s2DRect)
+            1900:  167(fvec3) Load 169(c3)
+            1901:   53(fvec2) Load 1409(dPdxy2)
+            1902:   53(fvec2) Load 1409(dPdxy2)
+            1903:    7(fvec4) ImageSampleProjExplicitLod 1899 1900 Grad 1901 1902
+            1904:    7(fvec4) Load 1820(texel)
+            1905:    7(fvec4) FAdd 1904 1903
+                              Store 1820(texel) 1905
+            1906:         357 Load 359(s2DRect)
+            1907:  175(fvec3) Load 177(f16c3)
+            1908:  154(fvec2) Load 1417(f16dPdxy2)
+            1909:  154(fvec2) Load 1417(f16dPdxy2)
+            1910:    7(fvec4) ImageSampleProjExplicitLod 1906 1907 Grad 1908 1909
+            1911:    7(fvec4) Load 1820(texel)
+            1912:    7(fvec4) FAdd 1911 1910
+                              Store 1820(texel) 1912
+            1913:         357 Load 359(s2DRect)
+            1914:  249(fvec4) Load 251(c4)
+            1915:   53(fvec2) Load 1409(dPdxy2)
+            1916:   53(fvec2) Load 1409(dPdxy2)
+            1917:   52(float) CompositeExtract 1914 3
+            1918:  249(fvec4) CompositeInsert 1917 1914 2
+            1919:    7(fvec4) ImageSampleProjExplicitLod 1913 1918 Grad 1915 1916
+            1920:    7(fvec4) Load 1820(texel)
+            1921:    7(fvec4) FAdd 1920 1919
+                              Store 1820(texel) 1921
+            1922:         357 Load 359(s2DRect)
+            1923:    7(fvec4) Load 309(f16c4)
+            1924:  154(fvec2) Load 1417(f16dPdxy2)
+            1925:  154(fvec2) Load 1417(f16dPdxy2)
+            1926:    6(float) CompositeExtract 1923 3
+            1927:    7(fvec4) CompositeInsert 1926 1923 2
+            1928:    7(fvec4) ImageSampleProjExplicitLod 1922 1927 Grad 1924 1925
+            1929:    7(fvec4) Load 1820(texel)
+            1930:    7(fvec4) FAdd 1929 1928
+                              Store 1820(texel) 1930
+            1931:         371 Load 373(s2DRectShadow)
+            1932:  249(fvec4) Load 251(c4)
+            1933:   53(fvec2) Load 1409(dPdxy2)
+            1934:   53(fvec2) Load 1409(dPdxy2)
+            1935:   52(float) CompositeExtract 1932 2
+            1936:   52(float) CompositeExtract 1932 3
+            1937:  249(fvec4) CompositeInsert 1936 1932 2
+            1938:    6(float) ImageSampleProjDrefExplicitLod 1931 1937 1935 Grad 1933 1934
+            1939:    208(ptr) AccessChain 1820(texel) 207
+            1940:    6(float) Load 1939
+            1941:    6(float) FAdd 1940 1938
+            1942:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1942 1941
+            1943:         371 Load 373(s2DRectShadow)
+            1944:  175(fvec3) Load 177(f16c3)
+            1945:   52(float) Load 215(compare)
+            1946:  154(fvec2) Load 1417(f16dPdxy2)
+            1947:  154(fvec2) Load 1417(f16dPdxy2)
+            1948:    6(float) ImageSampleProjDrefExplicitLod 1943 1944 1945 Grad 1946 1947
+            1949:    208(ptr) AccessChain 1820(texel) 207
+            1950:    6(float) Load 1949
+            1951:    6(float) FAdd 1950 1948
+            1952:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1952 1951
+            1953:         199 Load 201(s1DShadow)
+            1954:  249(fvec4) Load 251(c4)
+            1955:   52(float) Load 1393(dPdxy1)
+            1956:   52(float) Load 1393(dPdxy1)
+            1957:   52(float) CompositeExtract 1954 2
+            1958:   52(float) CompositeExtract 1954 3
+            1959:  249(fvec4) CompositeInsert 1958 1954 1
+            1960:    6(float) ImageSampleProjDrefExplicitLod 1953 1959 1957 Grad 1955 1956
+            1961:    208(ptr) AccessChain 1820(texel) 207
+            1962:    6(float) Load 1961
+            1963:    6(float) FAdd 1962 1960
+            1964:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1964 1963
+            1965:         199 Load 201(s1DShadow)
+            1966:  175(fvec3) Load 177(f16c3)
+            1967:   52(float) Load 215(compare)
+            1968:    6(float) Load 1401(f16dPdxy1)
+            1969:    6(float) Load 1401(f16dPdxy1)
+            1970:    6(float) CompositeExtract 1966 2
+            1971:  175(fvec3) CompositeInsert 1970 1966 1
+            1972:    6(float) ImageSampleProjDrefExplicitLod 1965 1971 1967 Grad 1968 1969
+            1973:    208(ptr) AccessChain 1820(texel) 207
+            1974:    6(float) Load 1973
+            1975:    6(float) FAdd 1974 1972
+            1976:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1976 1975
+            1977:         224 Load 226(s2DShadow)
+            1978:  249(fvec4) Load 251(c4)
+            1979:   53(fvec2) Load 1409(dPdxy2)
+            1980:   53(fvec2) Load 1409(dPdxy2)
+            1981:   52(float) CompositeExtract 1978 2
+            1982:   52(float) CompositeExtract 1978 3
+            1983:  249(fvec4) CompositeInsert 1982 1978 2
+            1984:    6(float) ImageSampleProjDrefExplicitLod 1977 1983 1981 Grad 1979 1980
+            1985:    208(ptr) AccessChain 1820(texel) 207
+            1986:    6(float) Load 1985
+            1987:    6(float) FAdd 1986 1984
+            1988:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1988 1987
+            1989:         224 Load 226(s2DShadow)
+            1990:  175(fvec3) Load 177(f16c3)
+            1991:   52(float) Load 215(compare)
+            1992:  154(fvec2) Load 1417(f16dPdxy2)
+            1993:  154(fvec2) Load 1417(f16dPdxy2)
+            1994:    6(float) ImageSampleProjDrefExplicitLod 1989 1990 1991 Grad 1992 1993
+            1995:    208(ptr) AccessChain 1820(texel) 207
+            1996:    6(float) Load 1995
+            1997:    6(float) FAdd 1996 1994
+            1998:    208(ptr) AccessChain 1820(texel) 207
+                              Store 1998 1997
+            1999:    7(fvec4) Load 1820(texel)
+                              ReturnValue 1999
+                              FunctionEnd
+33(testTextureProjGradoffset():    7(fvec4) Function None 8
+              34:             Label
+     2002(texel):     64(ptr) Variable Function
+                              Store 2002(texel) 121
+            2003:         123 Load 125(s1D)
+            2004:   53(fvec2) Load 148(c2)
+            2005:   52(float) Load 1393(dPdxy1)
+            2006:   52(float) Load 1393(dPdxy1)
+            2007:    7(fvec4) ImageSampleProjExplicitLod 2003 2004 Grad ConstOffset 2005 2006 709
+            2008:    7(fvec4) Load 2002(texel)
+            2009:    7(fvec4) FAdd 2008 2007
+                              Store 2002(texel) 2009
+            2010:         123 Load 125(s1D)
+            2011:  154(fvec2) Load 156(f16c2)
+            2012:    6(float) Load 1401(f16dPdxy1)
+            2013:    6(float) Load 1401(f16dPdxy1)
+            2014:    7(fvec4) ImageSampleProjExplicitLod 2010 2011 Grad ConstOffset 2012 2013 709
+            2015:    7(fvec4) Load 2002(texel)
+            2016:    7(fvec4) FAdd 2015 2014
+                              Store 2002(texel) 2016
+            2017:         123 Load 125(s1D)
+            2018:  249(fvec4) Load 251(c4)
+            2019:   52(float) Load 1393(dPdxy1)
+            2020:   52(float) Load 1393(dPdxy1)
+            2021:   52(float) CompositeExtract 2018 3
+            2022:  249(fvec4) CompositeInsert 2021 2018 1
+            2023:    7(fvec4) ImageSampleProjExplicitLod 2017 2022 Grad ConstOffset 2019 2020 709
+            2024:    7(fvec4) Load 2002(texel)
+            2025:    7(fvec4) FAdd 2024 2023
+                              Store 2002(texel) 2025
+            2026:         123 Load 125(s1D)
+            2027:    7(fvec4) Load 309(f16c4)
+            2028:    6(float) Load 1401(f16dPdxy1)
+            2029:    6(float) Load 1401(f16dPdxy1)
+            2030:    6(float) CompositeExtract 2027 3
+            2031:    7(fvec4) CompositeInsert 2030 2027 1
+            2032:    7(fvec4) ImageSampleProjExplicitLod 2026 2031 Grad ConstOffset 2028 2029 709
+            2033:    7(fvec4) Load 2002(texel)
+            2034:    7(fvec4) FAdd 2033 2032
+                              Store 2002(texel) 2034
+            2035:         143 Load 145(s2D)
+            2036:  167(fvec3) Load 169(c3)
+            2037:   53(fvec2) Load 1409(dPdxy2)
+            2038:   53(fvec2) Load 1409(dPdxy2)
+            2039:    7(fvec4) ImageSampleProjExplicitLod 2035 2036 Grad ConstOffset 2037 2038 722
+            2040:    7(fvec4) Load 2002(texel)
+            2041:    7(fvec4) FAdd 2040 2039
+                              Store 2002(texel) 2041
+            2042:         143 Load 145(s2D)
+            2043:  175(fvec3) Load 177(f16c3)
+            2044:  154(fvec2) Load 1417(f16dPdxy2)
+            2045:  154(fvec2) Load 1417(f16dPdxy2)
+            2046:    7(fvec4) ImageSampleProjExplicitLod 2042 2043 Grad ConstOffset 2044 2045 722
+            2047:    7(fvec4) Load 2002(texel)
+            2048:    7(fvec4) FAdd 2047 2046
+                              Store 2002(texel) 2048
+            2049:         143 Load 145(s2D)
+            2050:  249(fvec4) Load 251(c4)
+            2051:   53(fvec2) Load 1409(dPdxy2)
+            2052:   53(fvec2) Load 1409(dPdxy2)
+            2053:   52(float) CompositeExtract 2050 3
+            2054:  249(fvec4) CompositeInsert 2053 2050 2
+            2055:    7(fvec4) ImageSampleProjExplicitLod 2049 2054 Grad ConstOffset 2051 2052 722
+            2056:    7(fvec4) Load 2002(texel)
+            2057:    7(fvec4) FAdd 2056 2055
+                              Store 2002(texel) 2057
+            2058:         143 Load 145(s2D)
+            2059:    7(fvec4) Load 309(f16c4)
+            2060:  154(fvec2) Load 1417(f16dPdxy2)
+            2061:  154(fvec2) Load 1417(f16dPdxy2)
+            2062:    6(float) CompositeExtract 2059 3
+            2063:    7(fvec4) CompositeInsert 2062 2059 2
+            2064:    7(fvec4) ImageSampleProjExplicitLod 2058 2063 Grad ConstOffset 2060 2061 722
+            2065:    7(fvec4) Load 2002(texel)
+            2066:    7(fvec4) FAdd 2065 2064
+                              Store 2002(texel) 2066
+            2067:         357 Load 359(s2DRect)
+            2068:  167(fvec3) Load 169(c3)
+            2069:   53(fvec2) Load 1409(dPdxy2)
+            2070:   53(fvec2) Load 1409(dPdxy2)
+            2071:    7(fvec4) ImageSampleProjExplicitLod 2067 2068 Grad ConstOffset 2069 2070 722
+            2072:    7(fvec4) Load 2002(texel)
+            2073:    7(fvec4) FAdd 2072 2071
+                              Store 2002(texel) 2073
+            2074:         357 Load 359(s2DRect)
+            2075:  175(fvec3) Load 177(f16c3)
+            2076:  154(fvec2) Load 1417(f16dPdxy2)
+            2077:  154(fvec2) Load 1417(f16dPdxy2)
+            2078:    7(fvec4) ImageSampleProjExplicitLod 2074 2075 Grad ConstOffset 2076 2077 722
+            2079:    7(fvec4) Load 2002(texel)
+            2080:    7(fvec4) FAdd 2079 2078
+                              Store 2002(texel) 2080
+            2081:         357 Load 359(s2DRect)
+            2082:  249(fvec4) Load 251(c4)
+            2083:   53(fvec2) Load 1409(dPdxy2)
+            2084:   53(fvec2) Load 1409(dPdxy2)
+            2085:   52(float) CompositeExtract 2082 3
+            2086:  249(fvec4) CompositeInsert 2085 2082 2
+            2087:    7(fvec4) ImageSampleProjExplicitLod 2081 2086 Grad ConstOffset 2083 2084 722
+            2088:    7(fvec4) Load 2002(texel)
+            2089:    7(fvec4) FAdd 2088 2087
+                              Store 2002(texel) 2089
+            2090:         357 Load 359(s2DRect)
+            2091:    7(fvec4) Load 309(f16c4)
+            2092:  154(fvec2) Load 1417(f16dPdxy2)
+            2093:  154(fvec2) Load 1417(f16dPdxy2)
+            2094:    6(float) CompositeExtract 2091 3
+            2095:    7(fvec4) CompositeInsert 2094 2091 2
+            2096:    7(fvec4) ImageSampleProjExplicitLod 2090 2095 Grad ConstOffset 2092 2093 722
+            2097:    7(fvec4) Load 2002(texel)
+            2098:    7(fvec4) FAdd 2097 2096
+                              Store 2002(texel) 2098
+            2099:         371 Load 373(s2DRectShadow)
+            2100:  249(fvec4) Load 251(c4)
+            2101:   53(fvec2) Load 1409(dPdxy2)
+            2102:   53(fvec2) Load 1409(dPdxy2)
+            2103:   52(float) CompositeExtract 2100 2
+            2104:   52(float) CompositeExtract 2100 3
+            2105:  249(fvec4) CompositeInsert 2104 2100 2
+            2106:    6(float) ImageSampleProjDrefExplicitLod 2099 2105 2103 Grad ConstOffset 2101 2102 722
+            2107:    208(ptr) AccessChain 2002(texel) 207
+            2108:    6(float) Load 2107
+            2109:    6(float) FAdd 2108 2106
+            2110:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2110 2109
+            2111:         371 Load 373(s2DRectShadow)
+            2112:  175(fvec3) Load 177(f16c3)
+            2113:   52(float) Load 215(compare)
+            2114:  154(fvec2) Load 1417(f16dPdxy2)
+            2115:  154(fvec2) Load 1417(f16dPdxy2)
+            2116:    6(float) ImageSampleProjDrefExplicitLod 2111 2112 2113 Grad ConstOffset 2114 2115 722
+            2117:    208(ptr) AccessChain 2002(texel) 207
+            2118:    6(float) Load 2117
+            2119:    6(float) FAdd 2118 2116
+            2120:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2120 2119
+            2121:         163 Load 165(s3D)
+            2122:  249(fvec4) Load 251(c4)
+            2123:  167(fvec3) Load 1425(dPdxy3)
+            2124:  167(fvec3) Load 1425(dPdxy3)
+            2125:    7(fvec4) ImageSampleProjExplicitLod 2121 2122 Grad ConstOffset 2123 2124 735
+            2126:    7(fvec4) Load 2002(texel)
+            2127:    7(fvec4) FAdd 2126 2125
+                              Store 2002(texel) 2127
+            2128:         163 Load 165(s3D)
+            2129:    7(fvec4) Load 309(f16c4)
+            2130:  175(fvec3) Load 1433(f16dPdxy3)
+            2131:  175(fvec3) Load 1433(f16dPdxy3)
+            2132:    7(fvec4) ImageSampleProjExplicitLod 2128 2129 Grad ConstOffset 2130 2131 735
+            2133:    7(fvec4) Load 2002(texel)
+            2134:    7(fvec4) FAdd 2133 2132
+                              Store 2002(texel) 2134
+            2135:         199 Load 201(s1DShadow)
+            2136:  249(fvec4) Load 251(c4)
+            2137:   52(float) Load 1393(dPdxy1)
+            2138:   52(float) Load 1393(dPdxy1)
+            2139:   52(float) CompositeExtract 2136 2
+            2140:   52(float) CompositeExtract 2136 3
+            2141:  249(fvec4) CompositeInsert 2140 2136 1
+            2142:    6(float) ImageSampleProjDrefExplicitLod 2135 2141 2139 Grad ConstOffset 2137 2138 709
+            2143:    208(ptr) AccessChain 2002(texel) 207
+            2144:    6(float) Load 2143
+            2145:    6(float) FAdd 2144 2142
+            2146:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2146 2145
+            2147:         199 Load 201(s1DShadow)
+            2148:  175(fvec3) Load 177(f16c3)
+            2149:   52(float) Load 215(compare)
+            2150:    6(float) Load 1401(f16dPdxy1)
+            2151:    6(float) Load 1401(f16dPdxy1)
+            2152:    6(float) CompositeExtract 2148 2
+            2153:  175(fvec3) CompositeInsert 2152 2148 1
+            2154:    6(float) ImageSampleProjDrefExplicitLod 2147 2153 2149 Grad ConstOffset 2150 2151 709
+            2155:    208(ptr) AccessChain 2002(texel) 207
+            2156:    6(float) Load 2155
+            2157:    6(float) FAdd 2156 2154
+            2158:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2158 2157
+            2159:         224 Load 226(s2DShadow)
+            2160:  249(fvec4) Load 251(c4)
+            2161:   53(fvec2) Load 1409(dPdxy2)
+            2162:   53(fvec2) Load 1409(dPdxy2)
+            2163:   52(float) CompositeExtract 2160 2
+            2164:   52(float) CompositeExtract 2160 3
+            2165:  249(fvec4) CompositeInsert 2164 2160 2
+            2166:    6(float) ImageSampleProjDrefExplicitLod 2159 2165 2163 Grad ConstOffset 2161 2162 722
+            2167:    208(ptr) AccessChain 2002(texel) 207
+            2168:    6(float) Load 2167
+            2169:    6(float) FAdd 2168 2166
+            2170:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2170 2169
+            2171:         224 Load 226(s2DShadow)
+            2172:  175(fvec3) Load 177(f16c3)
+            2173:   52(float) Load 215(compare)
+            2174:  154(fvec2) Load 1417(f16dPdxy2)
+            2175:  154(fvec2) Load 1417(f16dPdxy2)
+            2176:    6(float) ImageSampleProjDrefExplicitLod 2171 2172 2173 Grad ConstOffset 2174 2175 722
+            2177:    208(ptr) AccessChain 2002(texel) 207
+            2178:    6(float) Load 2177
+            2179:    6(float) FAdd 2178 2176
+            2180:    208(ptr) AccessChain 2002(texel) 207
+                              Store 2180 2179
+            2181:    7(fvec4) Load 2002(texel)
+                              ReturnValue 2181
+                              FunctionEnd
+35(testTextureGather():    7(fvec4) Function None 8
+              36:             Label
+     2184(texel):     64(ptr) Variable Function
+                              Store 2184(texel) 121
+            2185:         143 Load 145(s2D)
+            2186:   53(fvec2) Load 148(c2)
+            2188:    7(fvec4) ImageGather 2185 2186 2187
+            2189:    7(fvec4) Load 2184(texel)
+            2190:    7(fvec4) FAdd 2189 2188
+                              Store 2184(texel) 2190
+            2191:         143 Load 145(s2D)
+            2192:  154(fvec2) Load 156(f16c2)
+            2193:    6(float) Load 137(f16bias)
+            2194:    7(fvec4) ImageGather 2191 2192 2187 Bias 2193
+            2195:    7(fvec4) Load 2184(texel)
+            2196:    7(fvec4) FAdd 2195 2194
+                              Store 2184(texel) 2196
+            2197:         284 Load 286(s2DArray)
+            2198:  167(fvec3) Load 169(c3)
+            2199:    7(fvec4) ImageGather 2197 2198 2187
+            2200:    7(fvec4) Load 2184(texel)
+            2201:    7(fvec4) FAdd 2200 2199
+                              Store 2184(texel) 2201
+            2202:         284 Load 286(s2DArray)
+            2203:  175(fvec3) Load 177(f16c3)
+            2204:    6(float) Load 137(f16bias)
+            2205:    7(fvec4) ImageGather 2202 2203 2187 Bias 2204
+            2206:    7(fvec4) Load 2184(texel)
+            2207:    7(fvec4) FAdd 2206 2205
+                              Store 2184(texel) 2207
+            2208:         184 Load 186(sCube)
+            2209:  167(fvec3) Load 169(c3)
+            2210:    7(fvec4) ImageGather 2208 2209 2187
+            2211:    7(fvec4) Load 2184(texel)
+            2212:    7(fvec4) FAdd 2211 2210
+                              Store 2184(texel) 2212
+            2213:         184 Load 186(sCube)
+            2214:  175(fvec3) Load 177(f16c3)
+            2215:    6(float) Load 137(f16bias)
+            2216:    7(fvec4) ImageGather 2213 2214 2187 Bias 2215
+            2217:    7(fvec4) Load 2184(texel)
+            2218:    7(fvec4) FAdd 2217 2216
+                              Store 2184(texel) 2218
+            2219:         299 Load 301(sCubeArray)
+            2220:  249(fvec4) Load 251(c4)
+            2221:    7(fvec4) ImageGather 2219 2220 2187
+            2222:    7(fvec4) Load 2184(texel)
+            2223:    7(fvec4) FAdd 2222 2221
+                              Store 2184(texel) 2223
+            2224:         299 Load 301(sCubeArray)
+            2225:    7(fvec4) Load 309(f16c4)
+            2226:    6(float) Load 137(f16bias)
+            2227:    7(fvec4) ImageGather 2224 2225 2187 Bias 2226
+            2228:    7(fvec4) Load 2184(texel)
+            2229:    7(fvec4) FAdd 2228 2227
+                              Store 2184(texel) 2229
+            2230:         357 Load 359(s2DRect)
+            2231:   53(fvec2) Load 148(c2)
+            2232:    7(fvec4) ImageGather 2230 2231 2187
+            2233:    7(fvec4) Load 2184(texel)
+            2234:    7(fvec4) FAdd 2233 2232
+                              Store 2184(texel) 2234
+            2235:         357 Load 359(s2DRect)
+            2236:  154(fvec2) Load 156(f16c2)
+            2237:    7(fvec4) ImageGather 2235 2236 2187
+            2238:    7(fvec4) Load 2184(texel)
+            2239:    7(fvec4) FAdd 2238 2237
+                              Store 2184(texel) 2239
+            2240:         224 Load 226(s2DShadow)
+            2241:   53(fvec2) Load 148(c2)
+            2242:   52(float) Load 215(compare)
+            2243:    7(fvec4) ImageDrefGather 2240 2241 2242
+            2244:    7(fvec4) Load 2184(texel)
+            2245:    7(fvec4) FAdd 2244 2243
+                              Store 2184(texel) 2245
+            2246:         224 Load 226(s2DShadow)
+            2247:  154(fvec2) Load 156(f16c2)
+            2248:   52(float) Load 215(compare)
+            2249:    7(fvec4) ImageDrefGather 2246 2247 2248
+            2250:    7(fvec4) Load 2184(texel)
+            2251:    7(fvec4) FAdd 2250 2249
+                              Store 2184(texel) 2251
+            2252:         337 Load 339(s2DArrayShadow)
+            2253:  167(fvec3) Load 169(c3)
+            2254:   52(float) Load 215(compare)
+            2255:    7(fvec4) ImageDrefGather 2252 2253 2254
+            2256:    7(fvec4) Load 2184(texel)
+            2257:    7(fvec4) FAdd 2256 2255
+                              Store 2184(texel) 2257
+            2258:         337 Load 339(s2DArrayShadow)
+            2259:  175(fvec3) Load 177(f16c3)
+            2260:   52(float) Load 215(compare)
+            2261:    7(fvec4) ImageDrefGather 2258 2259 2260
+            2262:    7(fvec4) Load 2184(texel)
+            2263:    7(fvec4) FAdd 2262 2261
+                              Store 2184(texel) 2263
+            2264:         245 Load 247(sCubeShadow)
+            2265:  167(fvec3) Load 169(c3)
+            2266:   52(float) Load 215(compare)
+            2267:    7(fvec4) ImageDrefGather 2264 2265 2266
+            2268:    7(fvec4) Load 2184(texel)
+            2269:    7(fvec4) FAdd 2268 2267
+                              Store 2184(texel) 2269
+            2270:         245 Load 247(sCubeShadow)
+            2271:  175(fvec3) Load 177(f16c3)
+            2272:   52(float) Load 215(compare)
+            2273:    7(fvec4) ImageDrefGather 2270 2271 2272
+            2274:    7(fvec4) Load 2184(texel)
+            2275:    7(fvec4) FAdd 2274 2273
+                              Store 2184(texel) 2275
+            2276:         391 Load 393(sCubeArrayShadow)
+            2277:  249(fvec4) Load 251(c4)
+            2278:   52(float) Load 215(compare)
+            2279:    7(fvec4) ImageDrefGather 2276 2277 2278
+            2280:    7(fvec4) Load 2184(texel)
+            2281:    7(fvec4) FAdd 2280 2279
+                              Store 2184(texel) 2281
+            2282:         391 Load 393(sCubeArrayShadow)
+            2283:    7(fvec4) Load 309(f16c4)
+            2284:   52(float) Load 215(compare)
+            2285:    7(fvec4) ImageDrefGather 2282 2283 2284
+            2286:    7(fvec4) Load 2184(texel)
+            2287:    7(fvec4) FAdd 2286 2285
+                              Store 2184(texel) 2287
+            2288:         371 Load 373(s2DRectShadow)
+            2289:   53(fvec2) Load 148(c2)
+            2290:   52(float) Load 215(compare)
+            2291:    7(fvec4) ImageDrefGather 2288 2289 2290
+            2292:    7(fvec4) Load 2184(texel)
+            2293:    7(fvec4) FAdd 2292 2291
+                              Store 2184(texel) 2293
+            2294:         371 Load 373(s2DRectShadow)
+            2295:  154(fvec2) Load 156(f16c2)
+            2296:   52(float) Load 215(compare)
+            2297:    7(fvec4) ImageDrefGather 2294 2295 2296
+            2298:    7(fvec4) Load 2184(texel)
+            2299:    7(fvec4) FAdd 2298 2297
+                              Store 2184(texel) 2299
+            2300:    7(fvec4) Load 2184(texel)
+                              ReturnValue 2300
+                              FunctionEnd
+37(testTextureGatherOffset():    7(fvec4) Function None 8
+              38:             Label
+     2303(texel):     64(ptr) Variable Function
+                              Store 2303(texel) 121
+            2304:         143 Load 145(s2D)
+            2305:   53(fvec2) Load 148(c2)
+            2306:    7(fvec4) ImageGather 2304 2305 2187 ConstOffset 722
+            2307:    7(fvec4) Load 2303(texel)
+            2308:    7(fvec4) FAdd 2307 2306
+                              Store 2303(texel) 2308
+            2309:         143 Load 145(s2D)
+            2310:  154(fvec2) Load 156(f16c2)
+            2311:    6(float) Load 137(f16bias)
+            2312:    7(fvec4) ImageGather 2309 2310 2187 Bias ConstOffset 2311 722
+            2313:    7(fvec4) Load 2303(texel)
+            2314:    7(fvec4) FAdd 2313 2312
+                              Store 2303(texel) 2314
+            2315:         284 Load 286(s2DArray)
+            2316:  167(fvec3) Load 169(c3)
+            2317:    7(fvec4) ImageGather 2315 2316 2187 ConstOffset 722
+            2318:    7(fvec4) Load 2303(texel)
+            2319:    7(fvec4) FAdd 2318 2317
+                              Store 2303(texel) 2319
+            2320:         284 Load 286(s2DArray)
+            2321:  175(fvec3) Load 177(f16c3)
+            2322:    6(float) Load 137(f16bias)
+            2323:    7(fvec4) ImageGather 2320 2321 2187 Bias ConstOffset 2322 722
+            2324:    7(fvec4) Load 2303(texel)
+            2325:    7(fvec4) FAdd 2324 2323
+                              Store 2303(texel) 2325
+            2326:         357 Load 359(s2DRect)
+            2327:   53(fvec2) Load 148(c2)
+            2328:    7(fvec4) ImageGather 2326 2327 2187 ConstOffset 722
+            2329:    7(fvec4) Load 2303(texel)
+            2330:    7(fvec4) FAdd 2329 2328
+                              Store 2303(texel) 2330
+            2331:         357 Load 359(s2DRect)
+            2332:  154(fvec2) Load 156(f16c2)
+            2333:    7(fvec4) ImageGather 2331 2332 2187 ConstOffset 722
+            2334:    7(fvec4) Load 2303(texel)
+            2335:    7(fvec4) FAdd 2334 2333
+                              Store 2303(texel) 2335
+            2336:         224 Load 226(s2DShadow)
+            2337:   53(fvec2) Load 148(c2)
+            2338:   52(float) Load 215(compare)
+            2339:    7(fvec4) ImageDrefGather 2336 2337 2338 ConstOffset 722
+            2340:    7(fvec4) Load 2303(texel)
+            2341:    7(fvec4) FAdd 2340 2339
+                              Store 2303(texel) 2341
+            2342:         224 Load 226(s2DShadow)
+            2343:  154(fvec2) Load 156(f16c2)
+            2344:   52(float) Load 215(compare)
+            2345:    7(fvec4) ImageDrefGather 2342 2343 2344 ConstOffset 722
+            2346:    7(fvec4) Load 2303(texel)
+            2347:    7(fvec4) FAdd 2346 2345
+                              Store 2303(texel) 2347
+            2348:         337 Load 339(s2DArrayShadow)
+            2349:  167(fvec3) Load 169(c3)
+            2350:   52(float) Load 215(compare)
+            2351:    7(fvec4) ImageDrefGather 2348 2349 2350 ConstOffset 722
+            2352:    7(fvec4) Load 2303(texel)
+            2353:    7(fvec4) FAdd 2352 2351
+                              Store 2303(texel) 2353
+            2354:         337 Load 339(s2DArrayShadow)
+            2355:  175(fvec3) Load 177(f16c3)
+            2356:   52(float) Load 215(compare)
+            2357:    7(fvec4) ImageDrefGather 2354 2355 2356 ConstOffset 722
+            2358:    7(fvec4) Load 2303(texel)
+            2359:    7(fvec4) FAdd 2358 2357
+                              Store 2303(texel) 2359
+            2360:         371 Load 373(s2DRectShadow)
+            2361:   53(fvec2) Load 148(c2)
+            2362:   52(float) Load 215(compare)
+            2363:    7(fvec4) ImageDrefGather 2360 2361 2362 ConstOffset 722
+            2364:    7(fvec4) Load 2303(texel)
+            2365:    7(fvec4) FAdd 2364 2363
+                              Store 2303(texel) 2365
+            2366:         371 Load 373(s2DRectShadow)
+            2367:  154(fvec2) Load 156(f16c2)
+            2368:   52(float) Load 215(compare)
+            2369:    7(fvec4) ImageDrefGather 2366 2367 2368 ConstOffset 722
+            2370:    7(fvec4) Load 2303(texel)
+            2371:    7(fvec4) FAdd 2370 2369
+                              Store 2303(texel) 2371
+            2372:    7(fvec4) Load 2303(texel)
+                              ReturnValue 2372
+                              FunctionEnd
+39(testTextureGatherOffsets():    7(fvec4) Function None 8
+              40:             Label
+     2375(texel):     64(ptr) Variable Function
+                              Store 2375(texel) 121
+            2376:         143 Load 145(s2D)
+            2377:   53(fvec2) Load 148(c2)
+            2381:    7(fvec4) ImageGather 2376 2377 2187 ConstOffsets 2380
+            2382:    7(fvec4) Load 2375(texel)
+            2383:    7(fvec4) FAdd 2382 2381
+                              Store 2375(texel) 2383
+            2384:         143 Load 145(s2D)
+            2385:  154(fvec2) Load 156(f16c2)
+            2386:    6(float) Load 137(f16bias)
+            2387:    7(fvec4) ImageGather 2384 2385 2187 Bias ConstOffsets 2386 2380
+            2388:    7(fvec4) Load 2375(texel)
+            2389:    7(fvec4) FAdd 2388 2387
+                              Store 2375(texel) 2389
+            2390:         284 Load 286(s2DArray)
+            2391:  167(fvec3) Load 169(c3)
+            2392:    7(fvec4) ImageGather 2390 2391 2187 ConstOffsets 2380
+            2393:    7(fvec4) Load 2375(texel)
+            2394:    7(fvec4) FAdd 2393 2392
+                              Store 2375(texel) 2394
+            2395:         284 Load 286(s2DArray)
+            2396:  175(fvec3) Load 177(f16c3)
+            2397:    6(float) Load 137(f16bias)
+            2398:    7(fvec4) ImageGather 2395 2396 2187 Bias ConstOffsets 2397 2380
+            2399:    7(fvec4) Load 2375(texel)
+            2400:    7(fvec4) FAdd 2399 2398
+                              Store 2375(texel) 2400
+            2401:         357 Load 359(s2DRect)
+            2402:   53(fvec2) Load 148(c2)
+            2403:    7(fvec4) ImageGather 2401 2402 2187 ConstOffsets 2380
+            2404:    7(fvec4) Load 2375(texel)
+            2405:    7(fvec4) FAdd 2404 2403
+                              Store 2375(texel) 2405
+            2406:         357 Load 359(s2DRect)
+            2407:  154(fvec2) Load 156(f16c2)
+            2408:    7(fvec4) ImageGather 2406 2407 2187 ConstOffsets 2380
+            2409:    7(fvec4) Load 2375(texel)
+            2410:    7(fvec4) FAdd 2409 2408
+                              Store 2375(texel) 2410
+            2411:         224 Load 226(s2DShadow)
+            2412:   53(fvec2) Load 148(c2)
+            2413:   52(float) Load 215(compare)
+            2414:    7(fvec4) ImageDrefGather 2411 2412 2413 ConstOffsets 2380
+            2415:    7(fvec4) Load 2375(texel)
+            2416:    7(fvec4) FAdd 2415 2414
+                              Store 2375(texel) 2416
+            2417:         224 Load 226(s2DShadow)
+            2418:  154(fvec2) Load 156(f16c2)
+            2419:   52(float) Load 215(compare)
+            2420:    7(fvec4) ImageDrefGather 2417 2418 2419 ConstOffsets 2380
+            2421:    7(fvec4) Load 2375(texel)
+            2422:    7(fvec4) FAdd 2421 2420
+                              Store 2375(texel) 2422
+            2423:         337 Load 339(s2DArrayShadow)
+            2424:  167(fvec3) Load 169(c3)
+            2425:   52(float) Load 215(compare)
+            2426:    7(fvec4) ImageDrefGather 2423 2424 2425 ConstOffsets 2380
+            2427:    7(fvec4) Load 2375(texel)
+            2428:    7(fvec4) FAdd 2427 2426
+                              Store 2375(texel) 2428
+            2429:         337 Load 339(s2DArrayShadow)
+            2430:  175(fvec3) Load 177(f16c3)
+            2431:   52(float) Load 215(compare)
+            2432:    7(fvec4) ImageDrefGather 2429 2430 2431 ConstOffsets 2380
+            2433:    7(fvec4) Load 2375(texel)
+            2434:    7(fvec4) FAdd 2433 2432
+                              Store 2375(texel) 2434
+            2435:         371 Load 373(s2DRectShadow)
+            2436:   53(fvec2) Load 148(c2)
+            2437:   52(float) Load 215(compare)
+            2438:    7(fvec4) ImageDrefGather 2435 2436 2437 ConstOffsets 2380
+            2439:    7(fvec4) Load 2375(texel)
+            2440:    7(fvec4) FAdd 2439 2438
+                              Store 2375(texel) 2440
+            2441:         371 Load 373(s2DRectShadow)
+            2442:  154(fvec2) Load 156(f16c2)
+            2443:   52(float) Load 215(compare)
+            2444:    7(fvec4) ImageDrefGather 2441 2442 2443 ConstOffsets 2380
+            2445:    7(fvec4) Load 2375(texel)
+            2446:    7(fvec4) FAdd 2445 2444
+                              Store 2375(texel) 2446
+            2447:    7(fvec4) Load 2375(texel)
+                              ReturnValue 2447
+                              FunctionEnd
+41(testTextureGatherLod():    7(fvec4) Function None 8
+              42:             Label
+     2450(texel):     64(ptr) Variable Function
+                              Store 2450(texel) 121
+            2451:         143 Load 145(s2D)
+            2452:   53(fvec2) Load 148(c2)
+            2453:   52(float) Load 565(lod)
+            2454:    7(fvec4) ImageGather 2451 2452 2187 Lod 2453
+            2455:    7(fvec4) Load 2450(texel)
+            2456:    7(fvec4) FAdd 2455 2454
+                              Store 2450(texel) 2456
+            2457:         143 Load 145(s2D)
+            2458:  154(fvec2) Load 156(f16c2)
+            2459:    6(float) Load 572(f16lod)
+            2460:    7(fvec4) ImageGather 2457 2458 2187 Lod 2459
+            2461:    7(fvec4) Load 2450(texel)
+            2462:    7(fvec4) FAdd 2461 2460
+                              Store 2450(texel) 2462
+            2463:         284 Load 286(s2DArray)
+            2464:  167(fvec3) Load 169(c3)
+            2465:   52(float) Load 565(lod)
+            2466:    7(fvec4) ImageGather 2463 2464 2187 Lod 2465
+            2467:    7(fvec4) Load 2450(texel)
+            2468:    7(fvec4) FAdd 2467 2466
+                              Store 2450(texel) 2468
+            2469:         284 Load 286(s2DArray)
+            2470:  175(fvec3) Load 177(f16c3)
+            2471:    6(float) Load 572(f16lod)
+            2472:    7(fvec4) ImageGather 2469 2470 2187 Lod 2471
+            2473:    7(fvec4) Load 2450(texel)
+            2474:    7(fvec4) FAdd 2473 2472
+                              Store 2450(texel) 2474
+            2475:         184 Load 186(sCube)
+            2476:  167(fvec3) Load 169(c3)
+            2477:   52(float) Load 565(lod)
+            2478:    7(fvec4) ImageGather 2475 2476 2187 Lod 2477
+            2479:    7(fvec4) Load 2450(texel)
+            2480:    7(fvec4) FAdd 2479 2478
+                              Store 2450(texel) 2480
+            2481:         184 Load 186(sCube)
+            2482:  175(fvec3) Load 177(f16c3)
+            2483:    6(float) Load 572(f16lod)
+            2484:    7(fvec4) ImageGather 2481 2482 2187 Lod 2483
+            2485:    7(fvec4) Load 2450(texel)
+            2486:    7(fvec4) FAdd 2485 2484
+                              Store 2450(texel) 2486
+            2487:         299 Load 301(sCubeArray)
+            2488:  249(fvec4) Load 251(c4)
+            2489:   52(float) Load 565(lod)
+            2490:    7(fvec4) ImageGather 2487 2488 2187 Lod 2489
+            2491:    7(fvec4) Load 2450(texel)
+            2492:    7(fvec4) FAdd 2491 2490
+                              Store 2450(texel) 2492
+            2493:         299 Load 301(sCubeArray)
+            2494:    7(fvec4) Load 309(f16c4)
+            2495:    6(float) Load 572(f16lod)
+            2496:    7(fvec4) ImageGather 2493 2494 2187 Lod 2495
+            2497:    7(fvec4) Load 2450(texel)
+            2498:    7(fvec4) FAdd 2497 2496
+                              Store 2450(texel) 2498
+            2499:    7(fvec4) Load 2450(texel)
+                              ReturnValue 2499
+                              FunctionEnd
+43(testTextureGatherLodOffset():    7(fvec4) Function None 8
+              44:             Label
+     2502(texel):     64(ptr) Variable Function
+                              Store 2502(texel) 121
+            2503:         143 Load 145(s2D)
+            2504:   53(fvec2) Load 148(c2)
+            2505:   52(float) Load 565(lod)
+            2506:    7(fvec4) ImageGather 2503 2504 2187 Lod ConstOffset 2505 722
+            2507:    7(fvec4) Load 2502(texel)
+            2508:    7(fvec4) FAdd 2507 2506
+                              Store 2502(texel) 2508
+            2509:         143 Load 145(s2D)
+            2510:  154(fvec2) Load 156(f16c2)
+            2511:    6(float) Load 572(f16lod)
+            2512:    7(fvec4) ImageGather 2509 2510 2187 Lod ConstOffset 2511 722
+            2513:    7(fvec4) Load 2502(texel)
+            2514:    7(fvec4) FAdd 2513 2512
+                              Store 2502(texel) 2514
+            2515:         284 Load 286(s2DArray)
+            2516:  167(fvec3) Load 169(c3)
+            2517:   52(float) Load 565(lod)
+            2518:    7(fvec4) ImageGather 2515 2516 2187 Lod ConstOffset 2517 722
+            2519:    7(fvec4) Load 2502(texel)
+            2520:    7(fvec4) FAdd 2519 2518
+                              Store 2502(texel) 2520
+            2521:         284 Load 286(s2DArray)
+            2522:  175(fvec3) Load 177(f16c3)
+            2523:    6(float) Load 572(f16lod)
+            2524:    7(fvec4) ImageGather 2521 2522 2187 Lod ConstOffset 2523 722
+            2525:    7(fvec4) Load 2502(texel)
+            2526:    7(fvec4) FAdd 2525 2524
+                              Store 2502(texel) 2526
+            2527:    7(fvec4) Load 2502(texel)
+                              ReturnValue 2527
+                              FunctionEnd
+45(testTextureGatherLodOffsets():    7(fvec4) Function None 8
+              46:             Label
+     2530(texel):     64(ptr) Variable Function
+                              Store 2530(texel) 121
+            2531:         143 Load 145(s2D)
+            2532:   53(fvec2) Load 148(c2)
+            2533:   52(float) Load 565(lod)
+            2534:    7(fvec4) ImageGather 2531 2532 2187 Lod ConstOffsets 2533 2380
+            2535:    7(fvec4) Load 2530(texel)
+            2536:    7(fvec4) FAdd 2535 2534
+                              Store 2530(texel) 2536
+            2537:         143 Load 145(s2D)
+            2538:  154(fvec2) Load 156(f16c2)
+            2539:    6(float) Load 572(f16lod)
+            2540:    7(fvec4) ImageGather 2537 2538 2187 Lod ConstOffsets 2539 2380
+            2541:    7(fvec4) Load 2530(texel)
+            2542:    7(fvec4) FAdd 2541 2540
+                              Store 2530(texel) 2542
+            2543:         284 Load 286(s2DArray)
+            2544:  167(fvec3) Load 169(c3)
+            2545:   52(float) Load 565(lod)
+            2546:    7(fvec4) ImageGather 2543 2544 2187 Lod ConstOffsets 2545 2380
+            2547:    7(fvec4) Load 2530(texel)
+            2548:    7(fvec4) FAdd 2547 2546
+                              Store 2530(texel) 2548
+            2549:         284 Load 286(s2DArray)
+            2550:  175(fvec3) Load 177(f16c3)
+            2551:    6(float) Load 572(f16lod)
+            2552:    7(fvec4) ImageGather 2549 2550 2187 Lod ConstOffsets 2551 2380
+            2553:    7(fvec4) Load 2530(texel)
+            2554:    7(fvec4) FAdd 2553 2552
+                              Store 2530(texel) 2554
+            2555:    7(fvec4) Load 2530(texel)
+                              ReturnValue 2555
+                              FunctionEnd
+50(testTextureSize():   48(ivec4) Function None 49
+              51:             Label
+      2559(size):   2558(ptr) Variable Function
+                              Store 2559(size) 2560
+            2561:         123 Load 125(s1D)
+            2562:   52(float) Load 565(lod)
+            2563:     47(int) ConvertFToS 2562
+            2564:         122 Image 2561
+            2565:     47(int) ImageQuerySizeLod 2564 2563
+            2567:   2566(ptr) AccessChain 2559(size) 207
+            2568:     47(int) Load 2567
+            2569:     47(int) IAdd 2568 2565
+            2570:   2566(ptr) AccessChain 2559(size) 207
+                              Store 2570 2569
+            2571:         143 Load 145(s2D)
+            2572:   52(float) Load 565(lod)
+            2573:     47(int) ConvertFToS 2572
+            2574:         142 Image 2571
+            2575:  721(ivec2) ImageQuerySizeLod 2574 2573
+            2576:   48(ivec4) Load 2559(size)
+            2577:  721(ivec2) VectorShuffle 2576 2576 0 1
+            2578:  721(ivec2) IAdd 2577 2575
+            2579:   48(ivec4) Load 2559(size)
+            2580:   48(ivec4) VectorShuffle 2579 2578 4 5 2 3
+                              Store 2559(size) 2580
+            2581:         163 Load 165(s3D)
+            2582:   52(float) Load 565(lod)
+            2583:     47(int) ConvertFToS 2582
+            2584:         162 Image 2581
+            2585:  734(ivec3) ImageQuerySizeLod 2584 2583
+            2586:   48(ivec4) Load 2559(size)
+            2587:  734(ivec3) VectorShuffle 2586 2586 0 1 2
+            2588:  734(ivec3) IAdd 2587 2585
+            2589:   48(ivec4) Load 2559(size)
+            2590:   48(ivec4) VectorShuffle 2589 2588 4 5 6 3
+                              Store 2559(size) 2590
+            2591:         184 Load 186(sCube)
+            2592:   52(float) Load 565(lod)
+            2593:     47(int) ConvertFToS 2592
+            2594:         183 Image 2591
+            2595:  721(ivec2) ImageQuerySizeLod 2594 2593
+            2596:   48(ivec4) Load 2559(size)
+            2597:  721(ivec2) VectorShuffle 2596 2596 0 1
+            2598:  721(ivec2) IAdd 2597 2595
+            2599:   48(ivec4) Load 2559(size)
+            2600:   48(ivec4) VectorShuffle 2599 2598 4 5 2 3
+                              Store 2559(size) 2600
+            2601:         199 Load 201(s1DShadow)
+            2602:   52(float) Load 565(lod)
+            2603:     47(int) ConvertFToS 2602
+            2604:         198 Image 2601
+            2605:     47(int) ImageQuerySizeLod 2604 2603
+            2606:   2566(ptr) AccessChain 2559(size) 207
+            2607:     47(int) Load 2606
+            2608:     47(int) IAdd 2607 2605
+            2609:   2566(ptr) AccessChain 2559(size) 207
+                              Store 2609 2608
+            2610:         224 Load 226(s2DShadow)
+            2611:   52(float) Load 565(lod)
+            2612:     47(int) ConvertFToS 2611
+            2613:         223 Image 2610
+            2614:  721(ivec2) ImageQuerySizeLod 2613 2612
+            2615:   48(ivec4) Load 2559(size)
+            2616:  721(ivec2) VectorShuffle 2615 2615 0 1
+            2617:  721(ivec2) IAdd 2616 2614
+            2618:   48(ivec4) Load 2559(size)
+            2619:   48(ivec4) VectorShuffle 2618 2617 4 5 2 3
+                              Store 2559(size) 2619
+            2620:         245 Load 247(sCubeShadow)
+            2621:   52(float) Load 565(lod)
+            2622:     47(int) ConvertFToS 2621
+            2623:         244 Image 2620
+            2624:  721(ivec2) ImageQuerySizeLod 2623 2622
+            2625:   48(ivec4) Load 2559(size)
+            2626:  721(ivec2) VectorShuffle 2625 2625 0 1
+            2627:  721(ivec2) IAdd 2626 2624
+            2628:   48(ivec4) Load 2559(size)
+            2629:   48(ivec4) VectorShuffle 2628 2627 4 5 2 3
+                              Store 2559(size) 2629
+            2630:         299 Load 301(sCubeArray)
+            2631:   52(float) Load 565(lod)
+            2632:     47(int) ConvertFToS 2631
+            2633:         298 Image 2630
+            2634:  734(ivec3) ImageQuerySizeLod 2633 2632
+            2635:   48(ivec4) Load 2559(size)
+            2636:  734(ivec3) VectorShuffle 2635 2635 0 1 2
+            2637:  734(ivec3) IAdd 2636 2634
+            2638:   48(ivec4) Load 2559(size)
+            2639:   48(ivec4) VectorShuffle 2638 2637 4 5 6 3
+                              Store 2559(size) 2639
+            2640:         391 Load 393(sCubeArrayShadow)
+            2641:   52(float) Load 565(lod)
+            2642:     47(int) ConvertFToS 2641
+            2643:         390 Image 2640
+            2644:  734(ivec3) ImageQuerySizeLod 2643 2642
+            2645:   48(ivec4) Load 2559(size)
+            2646:  734(ivec3) VectorShuffle 2645 2645 0 1 2
+            2647:  734(ivec3) IAdd 2646 2644
+            2648:   48(ivec4) Load 2559(size)
+            2649:   48(ivec4) VectorShuffle 2648 2647 4 5 6 3
+                              Store 2559(size) 2649
+            2650:         357 Load 359(s2DRect)
+            2651:         356 Image 2650
+            2652:  721(ivec2) ImageQuerySize 2651
+            2653:   48(ivec4) Load 2559(size)
+            2654:  721(ivec2) VectorShuffle 2653 2653 0 1
+            2655:  721(ivec2) IAdd 2654 2652
+            2656:   48(ivec4) Load 2559(size)
+            2657:   48(ivec4) VectorShuffle 2656 2655 4 5 2 3
+                              Store 2559(size) 2657
+            2658:         371 Load 373(s2DRectShadow)
+            2659:         370 Image 2658
+            2660:  721(ivec2) ImageQuerySize 2659
+            2661:   48(ivec4) Load 2559(size)
+            2662:  721(ivec2) VectorShuffle 2661 2661 0 1
+            2663:  721(ivec2) IAdd 2662 2660
+            2664:   48(ivec4) Load 2559(size)
+            2665:   48(ivec4) VectorShuffle 2664 2663 4 5 2 3
+                              Store 2559(size) 2665
+            2666:         269 Load 271(s1DArray)
+            2667:   52(float) Load 565(lod)
+            2668:     47(int) ConvertFToS 2667
+            2669:         268 Image 2666
+            2670:  721(ivec2) ImageQuerySizeLod 2669 2668
+            2671:   48(ivec4) Load 2559(size)
+            2672:  721(ivec2) VectorShuffle 2671 2671 0 1
+            2673:  721(ivec2) IAdd 2672 2670
+            2674:   48(ivec4) Load 2559(size)
+            2675:   48(ivec4) VectorShuffle 2674 2673 4 5 2 3
+                              Store 2559(size) 2675
+            2676:         284 Load 286(s2DArray)
+            2677:   52(float) Load 565(lod)
+            2678:     47(int) ConvertFToS 2677
+            2679:         283 Image 2676
+            2680:  734(ivec3) ImageQuerySizeLod 2679 2678
+            2681:   48(ivec4) Load 2559(size)
+            2682:  734(ivec3) VectorShuffle 2681 2681 0 1 2
+            2683:  734(ivec3) IAdd 2682 2680
+            2684:   48(ivec4) Load 2559(size)
+            2685:   48(ivec4) VectorShuffle 2684 2683 4 5 6 3
+                              Store 2559(size) 2685
+            2686:         316 Load 318(s1DArrayShadow)
+            2687:   52(float) Load 565(lod)
+            2688:     47(int) ConvertFToS 2687
+            2689:         315 Image 2686
+            2690:  721(ivec2) ImageQuerySizeLod 2689 2688
+            2691:   48(ivec4) Load 2559(size)
+            2692:  721(ivec2) VectorShuffle 2691 2691 0 1
+            2693:  721(ivec2) IAdd 2692 2690
+            2694:   48(ivec4) Load 2559(size)
+            2695:   48(ivec4) VectorShuffle 2694 2693 4 5 2 3
+                              Store 2559(size) 2695
+            2696:         337 Load 339(s2DArrayShadow)
+            2697:   52(float) Load 565(lod)
+            2698:     47(int) ConvertFToS 2697
+            2699:         336 Image 2696
+            2700:  734(ivec3) ImageQuerySizeLod 2699 2698
+            2701:   48(ivec4) Load 2559(size)
+            2702:  734(ivec3) VectorShuffle 2701 2701 0 1 2
+            2703:  734(ivec3) IAdd 2702 2700
+            2704:   48(ivec4) Load 2559(size)
+            2705:   48(ivec4) VectorShuffle 2704 2703 4 5 6 3
+                              Store 2559(size) 2705
+            2706:        1298 Load 1300(sBuffer)
+            2707:        1297 Image 2706
+            2708:     47(int) ImageQuerySize 2707
+            2709:   2566(ptr) AccessChain 2559(size) 207
+            2710:     47(int) Load 2709
+            2711:     47(int) IAdd 2710 2708
+            2712:   2566(ptr) AccessChain 2559(size) 207
+                              Store 2712 2711
+            2713:        1309 Load 1311(s2DMS)
+            2714:        1308 Image 2713
+            2715:  721(ivec2) ImageQuerySize 2714
+            2716:   48(ivec4) Load 2559(size)
+            2717:  721(ivec2) VectorShuffle 2716 2716 0 1
+            2718:  721(ivec2) IAdd 2717 2715
+            2719:   48(ivec4) Load 2559(size)
+            2720:   48(ivec4) VectorShuffle 2719 2718 4 5 2 3
+                              Store 2559(size) 2720
+            2721:        1320 Load 1322(s2DMSArray)
+            2722:        1319 Image 2721
+            2723:  734(ivec3) ImageQuerySize 2722
+            2724:   48(ivec4) Load 2559(size)
+            2725:  734(ivec3) VectorShuffle 2724 2724 0 1 2
+            2726:  734(ivec3) IAdd 2725 2723
+            2727:   48(ivec4) Load 2559(size)
+            2728:   48(ivec4) VectorShuffle 2727 2726 4 5 6 3
+                              Store 2559(size) 2728
+            2729:   48(ivec4) Load 2559(size)
+                              ReturnValue 2729
+                              FunctionEnd
+55(testTextureQueryLod():   53(fvec2) Function None 54
+              56:             Label
+       2733(lod):   2732(ptr) Variable Function
+                              Store 2733(lod) 2735
+            2736:         123 Load 125(s1D)
+            2737:   52(float) Load 128(c1)
+            2738:   53(fvec2) ImageQueryLod 2736 2737
+            2739:   53(fvec2) Load 2733(lod)
+            2740:   53(fvec2) FAdd 2739 2738
+                              Store 2733(lod) 2740
+            2741:         123 Load 125(s1D)
+            2742:    6(float) Load 135(f16c1)
+            2743:  154(fvec2) ImageQueryLod 2741 2742
+            2744:   53(fvec2) Load 2733(lod)
+            2745:   53(fvec2) FAdd 2744 2743
+                              Store 2733(lod) 2745
+            2746:         143 Load 145(s2D)
+            2747:   53(fvec2) Load 148(c2)
+            2748:   53(fvec2) ImageQueryLod 2746 2747
+            2749:   53(fvec2) Load 2733(lod)
+            2750:   53(fvec2) FAdd 2749 2748
+                              Store 2733(lod) 2750
+            2751:         143 Load 145(s2D)
+            2752:  154(fvec2) Load 156(f16c2)
+            2753:  154(fvec2) ImageQueryLod 2751 2752
+            2754:   53(fvec2) Load 2733(lod)
+            2755:   53(fvec2) FAdd 2754 2753
+                              Store 2733(lod) 2755
+            2756:         163 Load 165(s3D)
+            2757:  167(fvec3) Load 169(c3)
+            2758:   53(fvec2) ImageQueryLod 2756 2757
+            2759:   53(fvec2) Load 2733(lod)
+            2760:   53(fvec2) FAdd 2759 2758
+                              Store 2733(lod) 2760
+            2761:         163 Load 165(s3D)
+            2762:  175(fvec3) Load 177(f16c3)
+            2763:  154(fvec2) ImageQueryLod 2761 2762
+            2764:   53(fvec2) Load 2733(lod)
+            2765:   53(fvec2) FAdd 2764 2763
+                              Store 2733(lod) 2765
+            2766:         184 Load 186(sCube)
+            2767:  167(fvec3) Load 169(c3)
+            2768:   53(fvec2) ImageQueryLod 2766 2767
+            2769:   53(fvec2) Load 2733(lod)
+            2770:   53(fvec2) FAdd 2769 2768
+                              Store 2733(lod) 2770
+            2771:         184 Load 186(sCube)
+            2772:  175(fvec3) Load 177(f16c3)
+            2773:  154(fvec2) ImageQueryLod 2771 2772
+            2774:   53(fvec2) Load 2733(lod)
+            2775:   53(fvec2) FAdd 2774 2773
+                              Store 2733(lod) 2775
+            2776:         269 Load 271(s1DArray)
+            2777:   52(float) Load 128(c1)
+            2778:   53(fvec2) ImageQueryLod 2776 2777
+            2779:   53(fvec2) Load 2733(lod)
+            2780:   53(fvec2) FAdd 2779 2778
+                              Store 2733(lod) 2780
+            2781:         269 Load 271(s1DArray)
+            2782:    6(float) Load 135(f16c1)
+            2783:  154(fvec2) ImageQueryLod 2781 2782
+            2784:   53(fvec2) Load 2733(lod)
+            2785:   53(fvec2) FAdd 2784 2783
+                              Store 2733(lod) 2785
+            2786:         284 Load 286(s2DArray)
+            2787:   53(fvec2) Load 148(c2)
+            2788:   53(fvec2) ImageQueryLod 2786 2787
+            2789:   53(fvec2) Load 2733(lod)
+            2790:   53(fvec2) FAdd 2789 2788
+                              Store 2733(lod) 2790
+            2791:         284 Load 286(s2DArray)
+            2792:  154(fvec2) Load 156(f16c2)
+            2793:  154(fvec2) ImageQueryLod 2791 2792
+            2794:   53(fvec2) Load 2733(lod)
+            2795:   53(fvec2) FAdd 2794 2793
+                              Store 2733(lod) 2795
+            2796:         299 Load 301(sCubeArray)
+            2797:  167(fvec3) Load 169(c3)
+            2798:   53(fvec2) ImageQueryLod 2796 2797
+            2799:   53(fvec2) Load 2733(lod)
+            2800:   53(fvec2) FAdd 2799 2798
+                              Store 2733(lod) 2800
+            2801:         299 Load 301(sCubeArray)
+            2802:  175(fvec3) Load 177(f16c3)
+            2803:  154(fvec2) ImageQueryLod 2801 2802
+            2804:   53(fvec2) Load 2733(lod)
+            2805:   53(fvec2) FAdd 2804 2803
+                              Store 2733(lod) 2805
+            2806:         199 Load 201(s1DShadow)
+            2807:   52(float) Load 128(c1)
+            2808:   53(fvec2) ImageQueryLod 2806 2807
+            2809:   53(fvec2) Load 2733(lod)
+            2810:   53(fvec2) FAdd 2809 2808
+                              Store 2733(lod) 2810
+            2811:         199 Load 201(s1DShadow)
+            2812:    6(float) Load 135(f16c1)
+            2813:  154(fvec2) ImageQueryLod 2811 2812
+            2814:   53(fvec2) Load 2733(lod)
+            2815:   53(fvec2) FAdd 2814 2813
+                              Store 2733(lod) 2815
+            2816:         224 Load 226(s2DShadow)
+            2817:   53(fvec2) Load 148(c2)
+            2818:   53(fvec2) ImageQueryLod 2816 2817
+            2819:   53(fvec2) Load 2733(lod)
+            2820:   53(fvec2) FAdd 2819 2818
+                              Store 2733(lod) 2820
+            2821:         224 Load 226(s2DShadow)
+            2822:  154(fvec2) Load 156(f16c2)
+            2823:  154(fvec2) ImageQueryLod 2821 2822
+            2824:   53(fvec2) Load 2733(lod)
+            2825:   53(fvec2) FAdd 2824 2823
+                              Store 2733(lod) 2825
+            2826:         391 Load 393(sCubeArrayShadow)
+            2827:  167(fvec3) Load 169(c3)
+            2828:   53(fvec2) ImageQueryLod 2826 2827
+            2829:   53(fvec2) Load 2733(lod)
+            2830:   53(fvec2) FAdd 2829 2828
+                              Store 2733(lod) 2830
+            2831:         391 Load 393(sCubeArrayShadow)
+            2832:  175(fvec3) Load 177(f16c3)
+            2833:  154(fvec2) ImageQueryLod 2831 2832
+            2834:   53(fvec2) Load 2733(lod)
+            2835:   53(fvec2) FAdd 2834 2833
+                              Store 2733(lod) 2835
+            2836:         316 Load 318(s1DArrayShadow)
+            2837:   52(float) Load 128(c1)
+            2838:   53(fvec2) ImageQueryLod 2836 2837
+            2839:   53(fvec2) Load 2733(lod)
+            2840:   53(fvec2) FAdd 2839 2838
+                              Store 2733(lod) 2840
+            2841:         316 Load 318(s1DArrayShadow)
+            2842:    6(float) Load 135(f16c1)
+            2843:  154(fvec2) ImageQueryLod 2841 2842
+            2844:   53(fvec2) Load 2733(lod)
+            2845:   53(fvec2) FAdd 2844 2843
+                              Store 2733(lod) 2845
+            2846:         337 Load 339(s2DArrayShadow)
+            2847:   53(fvec2) Load 148(c2)
+            2848:   53(fvec2) ImageQueryLod 2846 2847
+            2849:   53(fvec2) Load 2733(lod)
+            2850:   53(fvec2) FAdd 2849 2848
+                              Store 2733(lod) 2850
+            2851:         337 Load 339(s2DArrayShadow)
+            2852:  154(fvec2) Load 156(f16c2)
+            2853:  154(fvec2) ImageQueryLod 2851 2852
+            2854:   53(fvec2) Load 2733(lod)
+            2855:   53(fvec2) FAdd 2854 2853
+                              Store 2733(lod) 2855
+            2856:         391 Load 393(sCubeArrayShadow)
+            2857:  167(fvec3) Load 169(c3)
+            2858:   53(fvec2) ImageQueryLod 2856 2857
+            2859:   53(fvec2) Load 2733(lod)
+            2860:   53(fvec2) FAdd 2859 2858
+                              Store 2733(lod) 2860
+            2861:         391 Load 393(sCubeArrayShadow)
+            2862:  175(fvec3) Load 177(f16c3)
+            2863:  154(fvec2) ImageQueryLod 2861 2862
+            2864:   53(fvec2) Load 2733(lod)
+            2865:   53(fvec2) FAdd 2864 2863
+                              Store 2733(lod) 2865
+            2866:   53(fvec2) Load 2733(lod)
+                              ReturnValue 2866
+                              FunctionEnd
+58(testTextureQueryLevels():     47(int) Function None 57
+              59:             Label
+    2869(levels):   2566(ptr) Variable Function
+                              Store 2869(levels) 2187
+            2870:         123 Load 125(s1D)
+            2871:         122 Image 2870
+            2872:     47(int) ImageQueryLevels 2871
+            2873:     47(int) Load 2869(levels)
+            2874:     47(int) IAdd 2873 2872
+                              Store 2869(levels) 2874
+            2875:         143 Load 145(s2D)
+            2876:         142 Image 2875
+            2877:     47(int) ImageQueryLevels 2876
+            2878:     47(int) Load 2869(levels)
+            2879:     47(int) IAdd 2878 2877
+                              Store 2869(levels) 2879
+            2880:         163 Load 165(s3D)
+            2881:         162 Image 2880
+            2882:     47(int) ImageQueryLevels 2881
+            2883:     47(int) Load 2869(levels)
+            2884:     47(int) IAdd 2883 2882
+                              Store 2869(levels) 2884
+            2885:         184 Load 186(sCube)
+            2886:         183 Image 2885
+            2887:     47(int) ImageQueryLevels 2886
+            2888:     47(int) Load 2869(levels)
+            2889:     47(int) IAdd 2888 2887
+                              Store 2869(levels) 2889
+            2890:         199 Load 201(s1DShadow)
+            2891:         198 Image 2890
+            2892:     47(int) ImageQueryLevels 2891
+            2893:     47(int) Load 2869(levels)
+            2894:     47(int) IAdd 2893 2892
+                              Store 2869(levels) 2894
+            2895:         224 Load 226(s2DShadow)
+            2896:         223 Image 2895
+            2897:     47(int) ImageQueryLevels 2896
+            2898:     47(int) Load 2869(levels)
+            2899:     47(int) IAdd 2898 2897
+                              Store 2869(levels) 2899
+            2900:         245 Load 247(sCubeShadow)
+            2901:         244 Image 2900
+            2902:     47(int) ImageQueryLevels 2901
+            2903:     47(int) Load 2869(levels)
+            2904:     47(int) IAdd 2903 2902
+                              Store 2869(levels) 2904
+            2905:         299 Load 301(sCubeArray)
+            2906:         298 Image 2905
+            2907:     47(int) ImageQueryLevels 2906
+            2908:     47(int) Load 2869(levels)
+            2909:     47(int) IAdd 2908 2907
+                              Store 2869(levels) 2909
+            2910:         391 Load 393(sCubeArrayShadow)
+            2911:         390 Image 2910
+            2912:     47(int) ImageQueryLevels 2911
+            2913:     47(int) Load 2869(levels)
+            2914:     47(int) IAdd 2913 2912
+                              Store 2869(levels) 2914
+            2915:         269 Load 271(s1DArray)
+            2916:         268 Image 2915
+            2917:     47(int) ImageQueryLevels 2916
+            2918:     47(int) Load 2869(levels)
+            2919:     47(int) IAdd 2918 2917
+                              Store 2869(levels) 2919
+            2920:         284 Load 286(s2DArray)
+            2921:         283 Image 2920
+            2922:     47(int) ImageQueryLevels 2921
+            2923:     47(int) Load 2869(levels)
+            2924:     47(int) IAdd 2923 2922
+                              Store 2869(levels) 2924
+            2925:         316 Load 318(s1DArrayShadow)
+            2926:         315 Image 2925
+            2927:     47(int) ImageQueryLevels 2926
+            2928:     47(int) Load 2869(levels)
+            2929:     47(int) IAdd 2928 2927
+                              Store 2869(levels) 2929
+            2930:         337 Load 339(s2DArrayShadow)
+            2931:         336 Image 2930
+            2932:     47(int) ImageQueryLevels 2931
+            2933:     47(int) Load 2869(levels)
+            2934:     47(int) IAdd 2933 2932
+                              Store 2869(levels) 2934
+            2935:     47(int) Load 2869(levels)
+                              ReturnValue 2935
+                              FunctionEnd
+60(testTextureSamples():     47(int) Function None 57
+              61:             Label
+   2938(samples):   2566(ptr) Variable Function
+                              Store 2938(samples) 2187
+            2939:        1309 Load 1311(s2DMS)
+            2940:        1308 Image 2939
+            2941:     47(int) ImageQuerySamples 2940
+            2942:     47(int) Load 2938(samples)
+            2943:     47(int) IAdd 2942 2941
+                              Store 2938(samples) 2943
+            2944:        1320 Load 1322(s2DMSArray)
+            2945:        1319 Image 2944
+            2946:     47(int) ImageQuerySamples 2945
+            2947:     47(int) Load 2938(samples)
+            2948:     47(int) IAdd 2947 2946
+                              Store 2938(samples) 2948
+            2949:     47(int) Load 2938(samples)
+                              ReturnValue 2949
+                              FunctionEnd
+62(testImageLoad():    7(fvec4) Function None 8
+              63:             Label
+     2952(texel):     64(ptr) Variable Function
+                              Store 2952(texel) 121
+            2956:        2953 Load 2955(i1D)
+            2957:   52(float) Load 128(c1)
+            2958:     47(int) ConvertFToS 2957
+            2959:    7(fvec4) ImageRead 2956 2958
+            2960:    7(fvec4) Load 2952(texel)
+            2961:    7(fvec4) FAdd 2960 2959
+                              Store 2952(texel) 2961
+            2965:        2962 Load 2964(i2D)
+            2966:   53(fvec2) Load 148(c2)
+            2967:  721(ivec2) ConvertFToS 2966
+            2968:    7(fvec4) ImageRead 2965 2967
+            2969:    7(fvec4) Load 2952(texel)
+            2970:    7(fvec4) FAdd 2969 2968
+                              Store 2952(texel) 2970
+            2974:        2971 Load 2973(i3D)
+            2975:  167(fvec3) Load 169(c3)
+            2976:  734(ivec3) ConvertFToS 2975
+            2977:    7(fvec4) ImageRead 2974 2976
+            2978:    7(fvec4) Load 2952(texel)
+            2979:    7(fvec4) FAdd 2978 2977
+                              Store 2952(texel) 2979
+            2983:        2980 Load 2982(i2DRect)
+            2984:   53(fvec2) Load 148(c2)
+            2985:  721(ivec2) ConvertFToS 2984
+            2986:    7(fvec4) ImageRead 2983 2985
+            2987:    7(fvec4) Load 2952(texel)
+            2988:    7(fvec4) FAdd 2987 2986
+                              Store 2952(texel) 2988
+            2992:        2989 Load 2991(iCube)
+            2993:  167(fvec3) Load 169(c3)
+            2994:  734(ivec3) ConvertFToS 2993
+            2995:    7(fvec4) ImageRead 2992 2994
+            2996:    7(fvec4) Load 2952(texel)
+            2997:    7(fvec4) FAdd 2996 2995
+                              Store 2952(texel) 2997
+            3001:        2998 Load 3000(iBuffer)
+            3002:   52(float) Load 128(c1)
+            3003:     47(int) ConvertFToS 3002
+            3004:    7(fvec4) ImageRead 3001 3003
+            3005:    7(fvec4) Load 2952(texel)
+            3006:    7(fvec4) FAdd 3005 3004
+                              Store 2952(texel) 3006
+            3010:        3007 Load 3009(i1DArray)
+            3011:   53(fvec2) Load 148(c2)
+            3012:  721(ivec2) ConvertFToS 3011
+            3013:    7(fvec4) ImageRead 3010 3012
+            3014:    7(fvec4) Load 2952(texel)
+            3015:    7(fvec4) FAdd 3014 3013
+                              Store 2952(texel) 3015
+            3019:        3016 Load 3018(i2DArray)
+            3020:  167(fvec3) Load 169(c3)
+            3021:  734(ivec3) ConvertFToS 3020
+            3022:    7(fvec4) ImageRead 3019 3021
+            3023:    7(fvec4) Load 2952(texel)
+            3024:    7(fvec4) FAdd 3023 3022
+                              Store 2952(texel) 3024
+            3028:        3025 Load 3027(iCubeArray)
+            3029:  167(fvec3) Load 169(c3)
+            3030:  734(ivec3) ConvertFToS 3029
+            3031:    7(fvec4) ImageRead 3028 3030
+            3032:    7(fvec4) Load 2952(texel)
+            3033:    7(fvec4) FAdd 3032 3031
+                              Store 2952(texel) 3033
+            3037:        3034 Load 3036(i2DMS)
+            3038:   53(fvec2) Load 148(c2)
+            3039:  721(ivec2) ConvertFToS 3038
+            3040:    7(fvec4) ImageRead 3037 3039 Sample 709
+            3041:    7(fvec4) Load 2952(texel)
+            3042:    7(fvec4) FAdd 3041 3040
+                              Store 2952(texel) 3042
+            3046:        3043 Load 3045(i2DMSArray)
+            3047:  167(fvec3) Load 169(c3)
+            3048:  734(ivec3) ConvertFToS 3047
+            3049:    7(fvec4) ImageRead 3046 3048 Sample 709
+            3050:    7(fvec4) Load 2952(texel)
+            3051:    7(fvec4) FAdd 3050 3049
+                              Store 2952(texel) 3051
+            3052:    7(fvec4) Load 2952(texel)
+                              ReturnValue 3052
+                              FunctionEnd
+67(testImageStore(vf164;):           2 Function None 65
+        66(data):     64(ptr) FunctionParameter
+              68:             Label
+            3055:        2953 Load 2955(i1D)
+            3056:   52(float) Load 128(c1)
+            3057:     47(int) ConvertFToS 3056
+            3058:    7(fvec4) Load 66(data)
+                              ImageWrite 3055 3057 3058
+            3059:        2962 Load 2964(i2D)
+            3060:   53(fvec2) Load 148(c2)
+            3061:  721(ivec2) ConvertFToS 3060
+            3062:    7(fvec4) Load 66(data)
+                              ImageWrite 3059 3061 3062
+            3063:        2971 Load 2973(i3D)
+            3064:  167(fvec3) Load 169(c3)
+            3065:  734(ivec3) ConvertFToS 3064
+            3066:    7(fvec4) Load 66(data)
+                              ImageWrite 3063 3065 3066
+            3067:        2980 Load 2982(i2DRect)
+            3068:   53(fvec2) Load 148(c2)
+            3069:  721(ivec2) ConvertFToS 3068
+            3070:    7(fvec4) Load 66(data)
+                              ImageWrite 3067 3069 3070
+            3071:        2989 Load 2991(iCube)
+            3072:  167(fvec3) Load 169(c3)
+            3073:  734(ivec3) ConvertFToS 3072
+            3074:    7(fvec4) Load 66(data)
+                              ImageWrite 3071 3073 3074
+            3075:        2998 Load 3000(iBuffer)
+            3076:   52(float) Load 128(c1)
+            3077:     47(int) ConvertFToS 3076
+            3078:    7(fvec4) Load 66(data)
+                              ImageWrite 3075 3077 3078
+            3079:        3007 Load 3009(i1DArray)
+            3080:   53(fvec2) Load 148(c2)
+            3081:  721(ivec2) ConvertFToS 3080
+            3082:    7(fvec4) Load 66(data)
+                              ImageWrite 3079 3081 3082
+            3083:        3016 Load 3018(i2DArray)
+            3084:  167(fvec3) Load 169(c3)
+            3085:  734(ivec3) ConvertFToS 3084
+            3086:    7(fvec4) Load 66(data)
+                              ImageWrite 3083 3085 3086
+            3087:        3025 Load 3027(iCubeArray)
+            3088:  167(fvec3) Load 169(c3)
+            3089:  734(ivec3) ConvertFToS 3088
+            3090:    7(fvec4) Load 66(data)
+                              ImageWrite 3087 3089 3090
+            3091:        3034 Load 3036(i2DMS)
+            3092:   53(fvec2) Load 148(c2)
+            3093:  721(ivec2) ConvertFToS 3092
+            3094:    7(fvec4) Load 66(data)
+                              ImageWrite 3091 3093 3094 Sample 709
+            3095:        3043 Load 3045(i2DMSArray)
+            3096:  167(fvec3) Load 169(c3)
+            3097:  734(ivec3) ConvertFToS 3096
+            3098:    7(fvec4) Load 66(data)
+                              ImageWrite 3095 3097 3098 Sample 709
+                              Return
+                              FunctionEnd
+69(testSparseTexture():    7(fvec4) Function None 8
+              70:             Label
+     3099(texel):     64(ptr) Variable Function
+                              Store 3099(texel) 121
+            3100:         143 Load 145(s2D)
+            3101:   53(fvec2) Load 148(c2)
+            3103:3102(ResType) ImageSparseSampleImplicitLod 3100 3101
+            3104:    7(fvec4) CompositeExtract 3103 1
+                              Store 3099(texel) 3104
+            3105:     47(int) CompositeExtract 3103 0
+            3106:         143 Load 145(s2D)
+            3107:  154(fvec2) Load 156(f16c2)
+            3108:    6(float) Load 137(f16bias)
+            3109:3102(ResType) ImageSparseSampleImplicitLod 3106 3107 Bias 3108
+            3110:    7(fvec4) CompositeExtract 3109 1
+                              Store 3099(texel) 3110
+            3111:     47(int) CompositeExtract 3109 0
+            3112:         163 Load 165(s3D)
+            3113:  167(fvec3) Load 169(c3)
+            3114:3102(ResType) ImageSparseSampleImplicitLod 3112 3113
+            3115:    7(fvec4) CompositeExtract 3114 1
+                              Store 3099(texel) 3115
+            3116:     47(int) CompositeExtract 3114 0
+            3117:         163 Load 165(s3D)
+            3118:  175(fvec3) Load 177(f16c3)
+            3119:    6(float) Load 137(f16bias)
+            3120:3102(ResType) ImageSparseSampleImplicitLod 3117 3118 Bias 3119
+            3121:    7(fvec4) CompositeExtract 3120 1
+                              Store 3099(texel) 3121
+            3122:     47(int) CompositeExtract 3120 0
+            3123:         184 Load 186(sCube)
+            3124:  167(fvec3) Load 169(c3)
+            3125:3102(ResType) ImageSparseSampleImplicitLod 3123 3124
+            3126:    7(fvec4) CompositeExtract 3125 1
+                              Store 3099(texel) 3126
+            3127:     47(int) CompositeExtract 3125 0
+            3128:         184 Load 186(sCube)
+            3129:  175(fvec3) Load 177(f16c3)
+            3130:    6(float) Load 137(f16bias)
+            3131:3102(ResType) ImageSparseSampleImplicitLod 3128 3129 Bias 3130
+            3132:    7(fvec4) CompositeExtract 3131 1
+                              Store 3099(texel) 3132
+            3133:     47(int) CompositeExtract 3131 0
+            3134:         224 Load 226(s2DShadow)
+            3135:  167(fvec3) Load 169(c3)
+            3136:    208(ptr) AccessChain 3099(texel) 207
+            3137:   52(float) CompositeExtract 3135 2
+            3139:3138(ResType) ImageSparseSampleDrefImplicitLod 3134 3135 3137
+            3140:    6(float) CompositeExtract 3139 1
+                              Store 3136 3140
+            3141:     47(int) CompositeExtract 3139 0
+            3142:         224 Load 226(s2DShadow)
+            3143:  154(fvec2) Load 156(f16c2)
+            3144:   52(float) Load 215(compare)
+            3145:    208(ptr) AccessChain 3099(texel) 207
+            3146:    6(float) Load 137(f16bias)
+            3147:3138(ResType) ImageSparseSampleDrefImplicitLod 3142 3143 3144 Bias 3146
+            3148:    6(float) CompositeExtract 3147 1
+                              Store 3145 3148
+            3149:     47(int) CompositeExtract 3147 0
+            3150:         245 Load 247(sCubeShadow)
+            3151:  249(fvec4) Load 251(c4)
+            3152:    208(ptr) AccessChain 3099(texel) 207
+            3153:   52(float) CompositeExtract 3151 3
+            3154:3138(ResType) ImageSparseSampleDrefImplicitLod 3150 3151 3153
+            3155:    6(float) CompositeExtract 3154 1
+                              Store 3152 3155
+            3156:     47(int) CompositeExtract 3154 0
+            3157:         245 Load 247(sCubeShadow)
+            3158:  175(fvec3) Load 177(f16c3)
+            3159:   52(float) Load 215(compare)
+            3160:    208(ptr) AccessChain 3099(texel) 207
+            3161:    6(float) Load 137(f16bias)
+            3162:3138(ResType) ImageSparseSampleDrefImplicitLod 3157 3158 3159 Bias 3161
+            3163:    6(float) CompositeExtract 3162 1
+                              Store 3160 3163
+            3164:     47(int) CompositeExtract 3162 0
+            3165:         284 Load 286(s2DArray)
+            3166:  167(fvec3) Load 169(c3)
+            3167:3102(ResType) ImageSparseSampleImplicitLod 3165 3166
+            3168:    7(fvec4) CompositeExtract 3167 1
+                              Store 3099(texel) 3168
+            3169:     47(int) CompositeExtract 3167 0
+            3170:         284 Load 286(s2DArray)
+            3171:  175(fvec3) Load 177(f16c3)
+            3172:    6(float) Load 137(f16bias)
+            3173:3102(ResType) ImageSparseSampleImplicitLod 3170 3171 Bias 3172
+            3174:    7(fvec4) CompositeExtract 3173 1
+                              Store 3099(texel) 3174
+            3175:     47(int) CompositeExtract 3173 0
+            3176:         299 Load 301(sCubeArray)
+            3177:  249(fvec4) Load 251(c4)
+            3178:3102(ResType) ImageSparseSampleImplicitLod 3176 3177
+            3179:    7(fvec4) CompositeExtract 3178 1
+                              Store 3099(texel) 3179
+            3180:     47(int) CompositeExtract 3178 0
+            3181:         299 Load 301(sCubeArray)
+            3182:    7(fvec4) Load 309(f16c4)
+            3183:    6(float) Load 137(f16bias)
+            3184:3102(ResType) ImageSparseSampleImplicitLod 3181 3182 Bias 3183
+            3185:    7(fvec4) CompositeExtract 3184 1
+                              Store 3099(texel) 3185
+            3186:     47(int) CompositeExtract 3184 0
+            3187:         337 Load 339(s2DArrayShadow)
+            3188:  249(fvec4) Load 251(c4)
+            3189:    208(ptr) AccessChain 3099(texel) 207
+            3190:   52(float) CompositeExtract 3188 3
+            3191:3138(ResType) ImageSparseSampleDrefImplicitLod 3187 3188 3190
+            3192:    6(float) CompositeExtract 3191 1
+                              Store 3189 3192
+            3193:     47(int) CompositeExtract 3191 0
+            3194:         337 Load 339(s2DArrayShadow)
+            3195:  175(fvec3) Load 177(f16c3)
+            3196:   52(float) Load 215(compare)
+            3197:    208(ptr) AccessChain 3099(texel) 207
+            3198:3138(ResType) ImageSparseSampleDrefImplicitLod 3194 3195 3196
+            3199:    6(float) CompositeExtract 3198 1
+                              Store 3197 3199
+            3200:     47(int) CompositeExtract 3198 0
+            3201:         357 Load 359(s2DRect)
+            3202:   53(fvec2) Load 148(c2)
+            3203:3102(ResType) ImageSparseSampleImplicitLod 3201 3202
+            3204:    7(fvec4) CompositeExtract 3203 1
+                              Store 3099(texel) 3204
+            3205:     47(int) CompositeExtract 3203 0
+            3206:         357 Load 359(s2DRect)
+            3207:  154(fvec2) Load 156(f16c2)
+            3208:3102(ResType) ImageSparseSampleImplicitLod 3206 3207
+            3209:    7(fvec4) CompositeExtract 3208 1
+                              Store 3099(texel) 3209
+            3210:     47(int) CompositeExtract 3208 0
+            3211:         371 Load 373(s2DRectShadow)
+            3212:  167(fvec3) Load 169(c3)
+            3213:    208(ptr) AccessChain 3099(texel) 207
+            3214:   52(float) CompositeExtract 3212 2
+            3215:3138(ResType) ImageSparseSampleDrefImplicitLod 3211 3212 3214
+            3216:    6(float) CompositeExtract 3215 1
+                              Store 3213 3216
+            3217:     47(int) CompositeExtract 3215 0
+            3218:         371 Load 373(s2DRectShadow)
+            3219:  154(fvec2) Load 156(f16c2)
+            3220:   52(float) Load 215(compare)
+            3221:    208(ptr) AccessChain 3099(texel) 207
+            3222:3138(ResType) ImageSparseSampleDrefImplicitLod 3218 3219 3220
+            3223:    6(float) CompositeExtract 3222 1
+                              Store 3221 3223
+            3224:     47(int) CompositeExtract 3222 0
+            3225:         391 Load 393(sCubeArrayShadow)
+            3226:  249(fvec4) Load 251(c4)
+            3227:   52(float) Load 215(compare)
+            3228:    208(ptr) AccessChain 3099(texel) 207
+            3229:3138(ResType) ImageSparseSampleDrefImplicitLod 3225 3226 3227
+            3230:    6(float) CompositeExtract 3229 1
+                              Store 3228 3230
+            3231:     47(int) CompositeExtract 3229 0
+            3232:         391 Load 393(sCubeArrayShadow)
+            3233:    7(fvec4) Load 309(f16c4)
+            3234:   52(float) Load 215(compare)
+            3235:    208(ptr) AccessChain 3099(texel) 207
+            3236:3138(ResType) ImageSparseSampleDrefImplicitLod 3232 3233 3234
+            3237:    6(float) CompositeExtract 3236 1
+                              Store 3235 3237
+            3238:     47(int) CompositeExtract 3236 0
+            3239:    7(fvec4) Load 3099(texel)
+                              ReturnValue 3239
+                              FunctionEnd
+71(testSparseTextureLod():    7(fvec4) Function None 8
+              72:             Label
+     3242(texel):     64(ptr) Variable Function
+                              Store 3242(texel) 121
+            3243:         143 Load 145(s2D)
+            3244:   53(fvec2) Load 148(c2)
+            3245:   52(float) Load 565(lod)
+            3246:3102(ResType) ImageSparseSampleExplicitLod 3243 3244 Lod 3245
+            3247:    7(fvec4) CompositeExtract 3246 1
+                              Store 3242(texel) 3247
+            3248:     47(int) CompositeExtract 3246 0
+            3249:         143 Load 145(s2D)
+            3250:  154(fvec2) Load 156(f16c2)
+            3251:    6(float) Load 572(f16lod)
+            3252:3102(ResType) ImageSparseSampleExplicitLod 3249 3250 Lod 3251
+            3253:    7(fvec4) CompositeExtract 3252 1
+                              Store 3242(texel) 3253
+            3254:     47(int) CompositeExtract 3252 0
+            3255:         163 Load 165(s3D)
+            3256:  167(fvec3) Load 169(c3)
+            3257:   52(float) Load 565(lod)
+            3258:3102(ResType) ImageSparseSampleExplicitLod 3255 3256 Lod 3257
+            3259:    7(fvec4) CompositeExtract 3258 1
+                              Store 3242(texel) 3259
+            3260:     47(int) CompositeExtract 3258 0
+            3261:         163 Load 165(s3D)
+            3262:  175(fvec3) Load 177(f16c3)
+            3263:    6(float) Load 572(f16lod)
+            3264:3102(ResType) ImageSparseSampleExplicitLod 3261 3262 Lod 3263
+            3265:    7(fvec4) CompositeExtract 3264 1
+                              Store 3242(texel) 3265
+            3266:     47(int) CompositeExtract 3264 0
+            3267:         184 Load 186(sCube)
+            3268:  167(fvec3) Load 169(c3)
+            3269:   52(float) Load 565(lod)
+            3270:3102(ResType) ImageSparseSampleExplicitLod 3267 3268 Lod 3269
+            3271:    7(fvec4) CompositeExtract 3270 1
+                              Store 3242(texel) 3271
+            3272:     47(int) CompositeExtract 3270 0
+            3273:         184 Load 186(sCube)
+            3274:  175(fvec3) Load 177(f16c3)
+            3275:    6(float) Load 572(f16lod)
+            3276:3102(ResType) ImageSparseSampleExplicitLod 3273 3274 Lod 3275
+            3277:    7(fvec4) CompositeExtract 3276 1
+                              Store 3242(texel) 3277
+            3278:     47(int) CompositeExtract 3276 0
+            3279:         224 Load 226(s2DShadow)
+            3280:  167(fvec3) Load 169(c3)
+            3281:   52(float) Load 565(lod)
+            3282:    208(ptr) AccessChain 3242(texel) 207
+            3283:   52(float) CompositeExtract 3280 2
+            3284:3138(ResType) ImageSparseSampleDrefExplicitLod 3279 3280 3283 Lod 3281
+            3285:    6(float) CompositeExtract 3284 1
+                              Store 3282 3285
+            3286:     47(int) CompositeExtract 3284 0
+            3287:         224 Load 226(s2DShadow)
+            3288:  154(fvec2) Load 156(f16c2)
+            3289:   52(float) Load 215(compare)
+            3290:    6(float) Load 572(f16lod)
+            3291:    208(ptr) AccessChain 3242(texel) 207
+            3292:3138(ResType) ImageSparseSampleDrefExplicitLod 3287 3288 3289 Lod 3290
+            3293:    6(float) CompositeExtract 3292 1
+                              Store 3291 3293
+            3294:     47(int) CompositeExtract 3292 0
+            3295:         284 Load 286(s2DArray)
+            3296:  167(fvec3) Load 169(c3)
+            3297:   52(float) Load 565(lod)
+            3298:3102(ResType) ImageSparseSampleExplicitLod 3295 3296 Lod 3297
+            3299:    7(fvec4) CompositeExtract 3298 1
+                              Store 3242(texel) 3299
+            3300:     47(int) CompositeExtract 3298 0
+            3301:         284 Load 286(s2DArray)
+            3302:  175(fvec3) Load 177(f16c3)
+            3303:    6(float) Load 572(f16lod)
+            3304:3102(ResType) ImageSparseSampleExplicitLod 3301 3302 Lod 3303
+            3305:    7(fvec4) CompositeExtract 3304 1
+                              Store 3242(texel) 3305
+            3306:     47(int) CompositeExtract 3304 0
+            3307:         299 Load 301(sCubeArray)
+            3308:  249(fvec4) Load 251(c4)
+            3309:   52(float) Load 565(lod)
+            3310:3102(ResType) ImageSparseSampleExplicitLod 3307 3308 Lod 3309
+            3311:    7(fvec4) CompositeExtract 3310 1
+                              Store 3242(texel) 3311
+            3312:     47(int) CompositeExtract 3310 0
+            3313:         299 Load 301(sCubeArray)
+            3314:    7(fvec4) Load 309(f16c4)
+            3315:    6(float) Load 572(f16lod)
+            3316:3102(ResType) ImageSparseSampleExplicitLod 3313 3314 Lod 3315
+            3317:    7(fvec4) CompositeExtract 3316 1
+                              Store 3242(texel) 3317
+            3318:     47(int) CompositeExtract 3316 0
+            3319:    7(fvec4) Load 3242(texel)
+                              ReturnValue 3319
+                              FunctionEnd
+73(testSparseTextureOffset():    7(fvec4) Function None 8
+              74:             Label
+     3322(texel):     64(ptr) Variable Function
+                              Store 3322(texel) 121
+            3323:         143 Load 145(s2D)
+            3324:   53(fvec2) Load 148(c2)
+            3325:3102(ResType) ImageSparseSampleImplicitLod 3323 3324 ConstOffset 722
+            3326:    7(fvec4) CompositeExtract 3325 1
+                              Store 3322(texel) 3326
+            3327:     47(int) CompositeExtract 3325 0
+            3328:         143 Load 145(s2D)
+            3329:  154(fvec2) Load 156(f16c2)
+            3330:    6(float) Load 137(f16bias)
+            3331:3102(ResType) ImageSparseSampleImplicitLod 3328 3329 Bias ConstOffset 3330 722
+            3332:    7(fvec4) CompositeExtract 3331 1
+                              Store 3322(texel) 3332
+            3333:     47(int) CompositeExtract 3331 0
+            3334:         163 Load 165(s3D)
+            3335:  167(fvec3) Load 169(c3)
+            3336:3102(ResType) ImageSparseSampleImplicitLod 3334 3335 ConstOffset 735
+            3337:    7(fvec4) CompositeExtract 3336 1
+                              Store 3322(texel) 3337
+            3338:     47(int) CompositeExtract 3336 0
+            3339:         163 Load 165(s3D)
+            3340:  175(fvec3) Load 177(f16c3)
+            3341:    6(float) Load 137(f16bias)
+            3342:3102(ResType) ImageSparseSampleImplicitLod 3339 3340 Bias ConstOffset 3341 735
+            3343:    7(fvec4) CompositeExtract 3342 1
+                              Store 3322(texel) 3343
+            3344:     47(int) CompositeExtract 3342 0
+            3345:         357 Load 359(s2DRect)
+            3346:   53(fvec2) Load 148(c2)
+            3347:3102(ResType) ImageSparseSampleImplicitLod 3345 3346 ConstOffset 722
+            3348:    7(fvec4) CompositeExtract 3347 1
+                              Store 3322(texel) 3348
+            3349:     47(int) CompositeExtract 3347 0
+            3350:         357 Load 359(s2DRect)
+            3351:  154(fvec2) Load 156(f16c2)
+            3352:3102(ResType) ImageSparseSampleImplicitLod 3350 3351 ConstOffset 722
+            3353:    7(fvec4) CompositeExtract 3352 1
+                              Store 3322(texel) 3353
+            3354:     47(int) CompositeExtract 3352 0
+            3355:         371 Load 373(s2DRectShadow)
+            3356:  167(fvec3) Load 169(c3)
+            3357:    208(ptr) AccessChain 3322(texel) 207
+            3358:   52(float) CompositeExtract 3356 2
+            3359:3138(ResType) ImageSparseSampleDrefImplicitLod 3355 3356 3358 ConstOffset 722
+            3360:    6(float) CompositeExtract 3359 1
+                              Store 3357 3360
+            3361:     47(int) CompositeExtract 3359 0
+            3362:         371 Load 373(s2DRectShadow)
+            3363:  154(fvec2) Load 156(f16c2)
+            3364:   52(float) Load 215(compare)
+            3365:    208(ptr) AccessChain 3322(texel) 207
+            3366:3138(ResType) ImageSparseSampleDrefImplicitLod 3362 3363 3364 ConstOffset 722
+            3367:    6(float) CompositeExtract 3366 1
+                              Store 3365 3367
+            3368:     47(int) CompositeExtract 3366 0
+            3369:         224 Load 226(s2DShadow)
+            3370:  167(fvec3) Load 169(c3)
+            3371:    208(ptr) AccessChain 3322(texel) 207
+            3372:   52(float) CompositeExtract 3370 2
+            3373:3138(ResType) ImageSparseSampleDrefImplicitLod 3369 3370 3372 ConstOffset 722
+            3374:    6(float) CompositeExtract 3373 1
+                              Store 3371 3374
+            3375:     47(int) CompositeExtract 3373 0
+            3376:         224 Load 226(s2DShadow)
+            3377:  154(fvec2) Load 156(f16c2)
+            3378:   52(float) Load 215(compare)
+            3379:    208(ptr) AccessChain 3322(texel) 207
+            3380:    6(float) Load 137(f16bias)
+            3381:3138(ResType) ImageSparseSampleDrefImplicitLod 3376 3377 3378 Bias ConstOffset 3380 722
+            3382:    6(float) CompositeExtract 3381 1
+                              Store 3379 3382
+            3383:     47(int) CompositeExtract 3381 0
+            3384:         284 Load 286(s2DArray)
+            3385:  167(fvec3) Load 169(c3)
+            3386:3102(ResType) ImageSparseSampleImplicitLod 3384 3385 ConstOffset 722
+            3387:    7(fvec4) CompositeExtract 3386 1
+                              Store 3322(texel) 3387
+            3388:     47(int) CompositeExtract 3386 0
+            3389:         284 Load 286(s2DArray)
+            3390:  175(fvec3) Load 177(f16c3)
+            3391:    6(float) Load 137(f16bias)
+            3392:3102(ResType) ImageSparseSampleImplicitLod 3389 3390 Bias ConstOffset 3391 722
+            3393:    7(fvec4) CompositeExtract 3392 1
+                              Store 3322(texel) 3393
+            3394:     47(int) CompositeExtract 3392 0
+            3395:         337 Load 339(s2DArrayShadow)
+            3396:  249(fvec4) Load 251(c4)
+            3397:    208(ptr) AccessChain 3322(texel) 207
+            3398:   52(float) CompositeExtract 3396 3
+            3399:3138(ResType) ImageSparseSampleDrefImplicitLod 3395 3396 3398 ConstOffset 722
+            3400:    6(float) CompositeExtract 3399 1
+                              Store 3397 3400
+            3401:     47(int) CompositeExtract 3399 0
+            3402:         337 Load 339(s2DArrayShadow)
+            3403:  175(fvec3) Load 177(f16c3)
+            3404:   52(float) Load 215(compare)
+            3405:    208(ptr) AccessChain 3322(texel) 207
+            3406:3138(ResType) ImageSparseSampleDrefImplicitLod 3402 3403 3404 ConstOffset 722
+            3407:    6(float) CompositeExtract 3406 1
+                              Store 3405 3407
+            3408:     47(int) CompositeExtract 3406 0
+            3409:    7(fvec4) Load 3322(texel)
+                              ReturnValue 3409
+                              FunctionEnd
+75(testSparseTextureLodOffset():    7(fvec4) Function None 8
+              76:             Label
+     3412(texel):     64(ptr) Variable Function
+                              Store 3412(texel) 121
+            3413:         143 Load 145(s2D)
+            3414:   53(fvec2) Load 148(c2)
+            3415:   52(float) Load 565(lod)
+            3416:3102(ResType) ImageSparseSampleExplicitLod 3413 3414 Lod ConstOffset 3415 722
+            3417:    7(fvec4) CompositeExtract 3416 1
+                              Store 3412(texel) 3417
+            3418:     47(int) CompositeExtract 3416 0
+            3419:         143 Load 145(s2D)
+            3420:  154(fvec2) Load 156(f16c2)
+            3421:    6(float) Load 572(f16lod)
+            3422:3102(ResType) ImageSparseSampleExplicitLod 3419 3420 Lod ConstOffset 3421 722
+            3423:    7(fvec4) CompositeExtract 3422 1
+                              Store 3412(texel) 3423
+            3424:     47(int) CompositeExtract 3422 0
+            3425:         163 Load 165(s3D)
+            3426:  167(fvec3) Load 169(c3)
+            3427:   52(float) Load 565(lod)
+            3428:3102(ResType) ImageSparseSampleExplicitLod 3425 3426 Lod ConstOffset 3427 735
+            3429:    7(fvec4) CompositeExtract 3428 1
+                              Store 3412(texel) 3429
+            3430:     47(int) CompositeExtract 3428 0
+            3431:         163 Load 165(s3D)
+            3432:  175(fvec3) Load 177(f16c3)
+            3433:    6(float) Load 572(f16lod)
+            3434:3102(ResType) ImageSparseSampleExplicitLod 3431 3432 Lod ConstOffset 3433 735
+            3435:    7(fvec4) CompositeExtract 3434 1
+                              Store 3412(texel) 3435
+            3436:     47(int) CompositeExtract 3434 0
+            3437:         224 Load 226(s2DShadow)
+            3438:  167(fvec3) Load 169(c3)
+            3439:   52(float) Load 565(lod)
+            3440:    208(ptr) AccessChain 3412(texel) 207
+            3441:   52(float) CompositeExtract 3438 2
+            3442:3138(ResType) ImageSparseSampleDrefExplicitLod 3437 3438 3441 Lod ConstOffset 3439 722
+            3443:    6(float) CompositeExtract 3442 1
+                              Store 3440 3443
+            3444:     47(int) CompositeExtract 3442 0
+            3445:         224 Load 226(s2DShadow)
+            3446:  154(fvec2) Load 156(f16c2)
+            3447:   52(float) Load 215(compare)
+            3448:    6(float) Load 572(f16lod)
+            3449:    208(ptr) AccessChain 3412(texel) 207
+            3450:3138(ResType) ImageSparseSampleDrefExplicitLod 3445 3446 3447 Lod ConstOffset 3448 722
+            3451:    6(float) CompositeExtract 3450 1
+                              Store 3449 3451
+            3452:     47(int) CompositeExtract 3450 0
+            3453:         284 Load 286(s2DArray)
+            3454:  167(fvec3) Load 169(c3)
+            3455:   52(float) Load 565(lod)
+            3456:3102(ResType) ImageSparseSampleExplicitLod 3453 3454 Lod ConstOffset 3455 722
+            3457:    7(fvec4) CompositeExtract 3456 1
+                              Store 3412(texel) 3457
+            3458:     47(int) CompositeExtract 3456 0
+            3459:         284 Load 286(s2DArray)
+            3460:  175(fvec3) Load 177(f16c3)
+            3461:    6(float) Load 572(f16lod)
+            3462:3102(ResType) ImageSparseSampleExplicitLod 3459 3460 Lod ConstOffset 3461 722
+            3463:    7(fvec4) CompositeExtract 3462 1
+                              Store 3412(texel) 3463
+            3464:     47(int) CompositeExtract 3462 0
+            3465:    7(fvec4) Load 3412(texel)
+                              ReturnValue 3465
+                              FunctionEnd
+77(testSparseTextureGrad():    7(fvec4) Function None 8
+              78:             Label
+     3468(texel):     64(ptr) Variable Function
+                              Store 3468(texel) 121
+            3469:         143 Load 145(s2D)
+            3470:   53(fvec2) Load 148(c2)
+            3471:   53(fvec2) Load 1409(dPdxy2)
+            3472:   53(fvec2) Load 1409(dPdxy2)
+            3473:3102(ResType) ImageSparseSampleExplicitLod 3469 3470 Grad 3471 3472
+            3474:    7(fvec4) CompositeExtract 3473 1
+                              Store 3468(texel) 3474
+            3475:     47(int) CompositeExtract 3473 0
+            3476:         143 Load 145(s2D)
+            3477:  154(fvec2) Load 156(f16c2)
+            3478:  154(fvec2) Load 1417(f16dPdxy2)
+            3479:  154(fvec2) Load 1417(f16dPdxy2)
+            3480:3102(ResType) ImageSparseSampleExplicitLod 3476 3477 Grad 3478 3479
+            3481:    7(fvec4) CompositeExtract 3480 1
+                              Store 3468(texel) 3481
+            3482:     47(int) CompositeExtract 3480 0
+            3483:         163 Load 165(s3D)
+            3484:  167(fvec3) Load 169(c3)
+            3485:  167(fvec3) Load 1425(dPdxy3)
+            3486:  167(fvec3) Load 1425(dPdxy3)
+            3487:3102(ResType) ImageSparseSampleExplicitLod 3483 3484 Grad 3485 3486
+            3488:    7(fvec4) CompositeExtract 3487 1
+                              Store 3468(texel) 3488
+            3489:     47(int) CompositeExtract 3487 0
+            3490:         163 Load 165(s3D)
+            3491:  175(fvec3) Load 177(f16c3)
+            3492:  175(fvec3) Load 1433(f16dPdxy3)
+            3493:  175(fvec3) Load 1433(f16dPdxy3)
+            3494:3102(ResType) ImageSparseSampleExplicitLod 3490 3491 Grad 3492 3493
+            3495:    7(fvec4) CompositeExtract 3494 1
+                              Store 3468(texel) 3495
+            3496:     47(int) CompositeExtract 3494 0
+            3497:         184 Load 186(sCube)
+            3498:  167(fvec3) Load 169(c3)
+            3499:  167(fvec3) Load 1425(dPdxy3)
+            3500:  167(fvec3) Load 1425(dPdxy3)
+            3501:3102(ResType) ImageSparseSampleExplicitLod 3497 3498 Grad 3499 3500
+            3502:    7(fvec4) CompositeExtract 3501 1
+                              Store 3468(texel) 3502
+            3503:     47(int) CompositeExtract 3501 0
+            3504:         184 Load 186(sCube)
+            3505:  175(fvec3) Load 177(f16c3)
+            3506:  175(fvec3) Load 1433(f16dPdxy3)
+            3507:  175(fvec3) Load 1433(f16dPdxy3)
+            3508:3102(ResType) ImageSparseSampleExplicitLod 3504 3505 Grad 3506 3507
+            3509:    7(fvec4) CompositeExtract 3508 1
+                              Store 3468(texel) 3509
+            3510:     47(int) CompositeExtract 3508 0
+            3511:         357 Load 359(s2DRect)
+            3512:   53(fvec2) Load 148(c2)
+            3513:   53(fvec2) Load 1409(dPdxy2)
+            3514:   53(fvec2) Load 1409(dPdxy2)
+            3515:3102(ResType) ImageSparseSampleExplicitLod 3511 3512 Grad 3513 3514
+            3516:    7(fvec4) CompositeExtract 3515 1
+                              Store 3468(texel) 3516
+            3517:     47(int) CompositeExtract 3515 0
+            3518:         357 Load 359(s2DRect)
+            3519:  154(fvec2) Load 156(f16c2)
+            3520:  154(fvec2) Load 1417(f16dPdxy2)
+            3521:  154(fvec2) Load 1417(f16dPdxy2)
+            3522:3102(ResType) ImageSparseSampleExplicitLod 3518 3519 Grad 3520 3521
+            3523:    7(fvec4) CompositeExtract 3522 1
+                              Store 3468(texel) 3523
+            3524:     47(int) CompositeExtract 3522 0
+            3525:         371 Load 373(s2DRectShadow)
+            3526:  167(fvec3) Load 169(c3)
+            3527:   53(fvec2) Load 1409(dPdxy2)
+            3528:   53(fvec2) Load 1409(dPdxy2)
+            3529:    208(ptr) AccessChain 3468(texel) 207
+            3530:   52(float) CompositeExtract 3526 2
+            3531:3138(ResType) ImageSparseSampleDrefExplicitLod 3525 3526 3530 Grad 3527 3528
+            3532:    6(float) CompositeExtract 3531 1
+                              Store 3529 3532
+            3533:     47(int) CompositeExtract 3531 0
+            3534:         371 Load 373(s2DRectShadow)
+            3535:  154(fvec2) Load 156(f16c2)
+            3536:   52(float) Load 215(compare)
+            3537:  154(fvec2) Load 1417(f16dPdxy2)
+            3538:  154(fvec2) Load 1417(f16dPdxy2)
+            3539:    208(ptr) AccessChain 3468(texel) 207
+            3540:3138(ResType) ImageSparseSampleDrefExplicitLod 3534 3535 3536 Grad 3537 3538
+            3541:    6(float) CompositeExtract 3540 1
+                              Store 3539 3541
+            3542:     47(int) CompositeExtract 3540 0
+            3543:         224 Load 226(s2DShadow)
+            3544:  167(fvec3) Load 169(c3)
+            3545:   53(fvec2) Load 1409(dPdxy2)
+            3546:   53(fvec2) Load 1409(dPdxy2)
+            3547:    208(ptr) AccessChain 3468(texel) 207
+            3548:   52(float) CompositeExtract 3544 2
+            3549:3138(ResType) ImageSparseSampleDrefExplicitLod 3543 3544 3548 Grad 3545 3546
+            3550:    6(float) CompositeExtract 3549 1
+                              Store 3547 3550
+            3551:     47(int) CompositeExtract 3549 0
+            3552:         224 Load 226(s2DShadow)
+            3553:  154(fvec2) Load 156(f16c2)
+            3554:   52(float) Load 215(compare)
+            3555:  154(fvec2) Load 1417(f16dPdxy2)
+            3556:  154(fvec2) Load 1417(f16dPdxy2)
+            3557:    208(ptr) AccessChain 3468(texel) 207
+            3558:3138(ResType) ImageSparseSampleDrefExplicitLod 3552 3553 3554 Grad 3555 3556
+            3559:    6(float) CompositeExtract 3558 1
+                              Store 3557 3559
+            3560:     47(int) CompositeExtract 3558 0
+            3561:         245 Load 247(sCubeShadow)
+            3562:  249(fvec4) Load 251(c4)
+            3563:  167(fvec3) Load 1425(dPdxy3)
+            3564:  167(fvec3) Load 1425(dPdxy3)
+            3565:    208(ptr) AccessChain 3468(texel) 207
+            3566:   52(float) CompositeExtract 3562 3
+            3567:3138(ResType) ImageSparseSampleDrefExplicitLod 3561 3562 3566 Grad 3563 3564
+            3568:    6(float) CompositeExtract 3567 1
+                              Store 3565 3568
+            3569:     47(int) CompositeExtract 3567 0
+            3570:         245 Load 247(sCubeShadow)
+            3571:  175(fvec3) Load 177(f16c3)
+            3572:   52(float) Load 215(compare)
+            3573:  175(fvec3) Load 1433(f16dPdxy3)
+            3574:  175(fvec3) Load 1433(f16dPdxy3)
+            3575:    208(ptr) AccessChain 3468(texel) 207
+            3576:3138(ResType) ImageSparseSampleDrefExplicitLod 3570 3571 3572 Grad 3573 3574
+            3577:    6(float) CompositeExtract 3576 1
+                              Store 3575 3577
+            3578:     47(int) CompositeExtract 3576 0
+            3579:         284 Load 286(s2DArray)
+            3580:  167(fvec3) Load 169(c3)
+            3581:   53(fvec2) Load 1409(dPdxy2)
+            3582:   53(fvec2) Load 1409(dPdxy2)
+            3583:3102(ResType) ImageSparseSampleExplicitLod 3579 3580 Grad 3581 3582
+            3584:    7(fvec4) CompositeExtract 3583 1
+                              Store 3468(texel) 3584
+            3585:     47(int) CompositeExtract 3583 0
+            3586:         284 Load 286(s2DArray)
+            3587:  175(fvec3) Load 177(f16c3)
+            3588:  154(fvec2) Load 1417(f16dPdxy2)
+            3589:  154(fvec2) Load 1417(f16dPdxy2)
+            3590:3102(ResType) ImageSparseSampleExplicitLod 3586 3587 Grad 3588 3589
+            3591:    7(fvec4) CompositeExtract 3590 1
+                              Store 3468(texel) 3591
+            3592:     47(int) CompositeExtract 3590 0
+            3593:         337 Load 339(s2DArrayShadow)
+            3594:  249(fvec4) Load 251(c4)
+            3595:   53(fvec2) Load 1409(dPdxy2)
+            3596:   53(fvec2) Load 1409(dPdxy2)
+            3597:    208(ptr) AccessChain 3468(texel) 207
+            3598:   52(float) CompositeExtract 3594 3
+            3599:3138(ResType) ImageSparseSampleDrefExplicitLod 3593 3594 3598 Grad 3595 3596
+            3600:    6(float) CompositeExtract 3599 1
+                              Store 3597 3600
+            3601:     47(int) CompositeExtract 3599 0
+            3602:         337 Load 339(s2DArrayShadow)
+            3603:  175(fvec3) Load 177(f16c3)
+            3604:   52(float) Load 215(compare)
+            3605:  154(fvec2) Load 1417(f16dPdxy2)
+            3606:  154(fvec2) Load 1417(f16dPdxy2)
+            3607:    208(ptr) AccessChain 3468(texel) 207
+            3608:3138(ResType) ImageSparseSampleDrefExplicitLod 3602 3603 3604 Grad 3605 3606
+            3609:    6(float) CompositeExtract 3608 1
+                              Store 3607 3609
+            3610:     47(int) CompositeExtract 3608 0
+            3611:         299 Load 301(sCubeArray)
+            3612:  249(fvec4) Load 251(c4)
+            3613:  167(fvec3) Load 1425(dPdxy3)
+            3614:  167(fvec3) Load 1425(dPdxy3)
+            3615:3102(ResType) ImageSparseSampleExplicitLod 3611 3612 Grad 3613 3614
+            3616:    7(fvec4) CompositeExtract 3615 1
+                              Store 3468(texel) 3616
+            3617:     47(int) CompositeExtract 3615 0
+            3618:         299 Load 301(sCubeArray)
+            3619:    7(fvec4) Load 309(f16c4)
+            3620:  175(fvec3) Load 1433(f16dPdxy3)
+            3621:  175(fvec3) Load 1433(f16dPdxy3)
+            3622:3102(ResType) ImageSparseSampleExplicitLod 3618 3619 Grad 3620 3621
+            3623:    7(fvec4) CompositeExtract 3622 1
+                              Store 3468(texel) 3623
+            3624:     47(int) CompositeExtract 3622 0
+            3625:    7(fvec4) Load 3468(texel)
+                              ReturnValue 3625
+                              FunctionEnd
+79(testSparseTextureGradOffset():    7(fvec4) Function None 8
+              80:             Label
+     3628(texel):     64(ptr) Variable Function
+                              Store 3628(texel) 121
+            3629:         143 Load 145(s2D)
+            3630:   53(fvec2) Load 148(c2)
+            3631:   53(fvec2) Load 1409(dPdxy2)
+            3632:   53(fvec2) Load 1409(dPdxy2)
+            3633:3102(ResType) ImageSparseSampleExplicitLod 3629 3630 Grad ConstOffset 3631 3632 722
+            3634:    7(fvec4) CompositeExtract 3633 1
+                              Store 3628(texel) 3634
+            3635:     47(int) CompositeExtract 3633 0
+            3636:         143 Load 145(s2D)
+            3637:  154(fvec2) Load 156(f16c2)
+            3638:  154(fvec2) Load 1417(f16dPdxy2)
+            3639:  154(fvec2) Load 1417(f16dPdxy2)
+            3640:3102(ResType) ImageSparseSampleExplicitLod 3636 3637 Grad ConstOffset 3638 3639 722
+            3641:    7(fvec4) CompositeExtract 3640 1
+                              Store 3628(texel) 3641
+            3642:     47(int) CompositeExtract 3640 0
+            3643:         163 Load 165(s3D)
+            3644:  167(fvec3) Load 169(c3)
+            3645:  167(fvec3) Load 1425(dPdxy3)
+            3646:  167(fvec3) Load 1425(dPdxy3)
+            3647:3102(ResType) ImageSparseSampleExplicitLod 3643 3644 Grad ConstOffset 3645 3646 735
+            3648:    7(fvec4) CompositeExtract 3647 1
+                              Store 3628(texel) 3648
+            3649:     47(int) CompositeExtract 3647 0
+            3650:         163 Load 165(s3D)
+            3651:  175(fvec3) Load 177(f16c3)
+            3652:  175(fvec3) Load 1433(f16dPdxy3)
+            3653:  175(fvec3) Load 1433(f16dPdxy3)
+            3654:3102(ResType) ImageSparseSampleExplicitLod 3650 3651 Grad ConstOffset 3652 3653 735
+            3655:    7(fvec4) CompositeExtract 3654 1
+                              Store 3628(texel) 3655
+            3656:     47(int) CompositeExtract 3654 0
+            3657:         357 Load 359(s2DRect)
+            3658:   53(fvec2) Load 148(c2)
+            3659:   53(fvec2) Load 1409(dPdxy2)
+            3660:   53(fvec2) Load 1409(dPdxy2)
+            3661:3102(ResType) ImageSparseSampleExplicitLod 3657 3658 Grad ConstOffset 3659 3660 722
+            3662:    7(fvec4) CompositeExtract 3661 1
+                              Store 3628(texel) 3662
+            3663:     47(int) CompositeExtract 3661 0
+            3664:         357 Load 359(s2DRect)
+            3665:  154(fvec2) Load 156(f16c2)
+            3666:  154(fvec2) Load 1417(f16dPdxy2)
+            3667:  154(fvec2) Load 1417(f16dPdxy2)
+            3668:3102(ResType) ImageSparseSampleExplicitLod 3664 3665 Grad ConstOffset 3666 3667 722
+            3669:    7(fvec4) CompositeExtract 3668 1
+                              Store 3628(texel) 3669
+            3670:     47(int) CompositeExtract 3668 0
+            3671:         371 Load 373(s2DRectShadow)
+            3672:  167(fvec3) Load 169(c3)
+            3673:   53(fvec2) Load 1409(dPdxy2)
+            3674:   53(fvec2) Load 1409(dPdxy2)
+            3675:    208(ptr) AccessChain 3628(texel) 207
+            3676:   52(float) CompositeExtract 3672 2
+            3677:3138(ResType) ImageSparseSampleDrefExplicitLod 3671 3672 3676 Grad ConstOffset 3673 3674 722
+            3678:    6(float) CompositeExtract 3677 1
+                              Store 3675 3678
+            3679:     47(int) CompositeExtract 3677 0
+            3680:         371 Load 373(s2DRectShadow)
+            3681:  154(fvec2) Load 156(f16c2)
+            3682:   52(float) Load 215(compare)
+            3683:  154(fvec2) Load 1417(f16dPdxy2)
+            3684:  154(fvec2) Load 1417(f16dPdxy2)
+            3685:    208(ptr) AccessChain 3628(texel) 207
+            3686:3138(ResType) ImageSparseSampleDrefExplicitLod 3680 3681 3682 Grad ConstOffset 3683 3684 722
+            3687:    6(float) CompositeExtract 3686 1
+                              Store 3685 3687
+            3688:     47(int) CompositeExtract 3686 0
+            3689:         224 Load 226(s2DShadow)
+            3690:  167(fvec3) Load 169(c3)
+            3691:   53(fvec2) Load 1409(dPdxy2)
+            3692:   53(fvec2) Load 1409(dPdxy2)
+            3693:    208(ptr) AccessChain 3628(texel) 207
+            3694:   52(float) CompositeExtract 3690 2
+            3695:3138(ResType) ImageSparseSampleDrefExplicitLod 3689 3690 3694 Grad ConstOffset 3691 3692 722
+            3696:    6(float) CompositeExtract 3695 1
+                              Store 3693 3696
+            3697:     47(int) CompositeExtract 3695 0
+            3698:         224 Load 226(s2DShadow)
+            3699:  154(fvec2) Load 156(f16c2)
+            3700:   52(float) Load 215(compare)
+            3701:  154(fvec2) Load 1417(f16dPdxy2)
+            3702:  154(fvec2) Load 1417(f16dPdxy2)
+            3703:    208(ptr) AccessChain 3628(texel) 207
+            3704:3138(ResType) ImageSparseSampleDrefExplicitLod 3698 3699 3700 Grad ConstOffset 3701 3702 722
+            3705:    6(float) CompositeExtract 3704 1
+                              Store 3703 3705
+            3706:     47(int) CompositeExtract 3704 0
+            3707:         284 Load 286(s2DArray)
+            3708:  167(fvec3) Load 169(c3)
+            3709:   53(fvec2) Load 1409(dPdxy2)
+            3710:   53(fvec2) Load 1409(dPdxy2)
+            3711:3102(ResType) ImageSparseSampleExplicitLod 3707 3708 Grad ConstOffset 3709 3710 722
+            3712:    7(fvec4) CompositeExtract 3711 1
+                              Store 3628(texel) 3712
+            3713:     47(int) CompositeExtract 3711 0
+            3714:         284 Load 286(s2DArray)
+            3715:  175(fvec3) Load 177(f16c3)
+            3716:  154(fvec2) Load 1417(f16dPdxy2)
+            3717:  154(fvec2) Load 1417(f16dPdxy2)
+            3718:3102(ResType) ImageSparseSampleExplicitLod 3714 3715 Grad ConstOffset 3716 3717 722
+            3719:    7(fvec4) CompositeExtract 3718 1
+                              Store 3628(texel) 3719
+            3720:     47(int) CompositeExtract 3718 0
+            3721:         337 Load 339(s2DArrayShadow)
+            3722:  249(fvec4) Load 251(c4)
+            3723:   53(fvec2) Load 1409(dPdxy2)
+            3724:   53(fvec2) Load 1409(dPdxy2)
+            3725:    208(ptr) AccessChain 3628(texel) 207
+            3726:   52(float) CompositeExtract 3722 3
+            3727:3138(ResType) ImageSparseSampleDrefExplicitLod 3721 3722 3726 Grad ConstOffset 3723 3724 722
+            3728:    6(float) CompositeExtract 3727 1
+                              Store 3725 3728
+            3729:     47(int) CompositeExtract 3727 0
+            3730:         337 Load 339(s2DArrayShadow)
+            3731:  175(fvec3) Load 177(f16c3)
+            3732:   52(float) Load 215(compare)
+            3733:  154(fvec2) Load 1417(f16dPdxy2)
+            3734:  154(fvec2) Load 1417(f16dPdxy2)
+            3735:    208(ptr) AccessChain 3628(texel) 207
+            3736:3138(ResType) ImageSparseSampleDrefExplicitLod 3730 3731 3732 Grad ConstOffset 3733 3734 722
+            3737:    6(float) CompositeExtract 3736 1
+                              Store 3735 3737
+            3738:     47(int) CompositeExtract 3736 0
+            3739:    7(fvec4) Load 3628(texel)
+                              ReturnValue 3739
+                              FunctionEnd
+81(testSparseTexelFetch():    7(fvec4) Function None 8
+              82:             Label
+     3742(texel):     64(ptr) Variable Function
+                              Store 3742(texel) 121
+            3743:         143 Load 145(s2D)
+            3744:   53(fvec2) Load 148(c2)
+            3745:  721(ivec2) ConvertFToS 3744
+            3746:   52(float) Load 565(lod)
+            3747:     47(int) ConvertFToS 3746
+            3748:         142 Image 3743
+            3749:3102(ResType) ImageSparseFetch 3748 3745 Lod 3747
+            3750:    7(fvec4) CompositeExtract 3749 1
+                              Store 3742(texel) 3750
+            3751:     47(int) CompositeExtract 3749 0
+            3752:         163 Load 165(s3D)
+            3753:  167(fvec3) Load 169(c3)
+            3754:  734(ivec3) ConvertFToS 3753
+            3755:   52(float) Load 565(lod)
+            3756:     47(int) ConvertFToS 3755
+            3757:         162 Image 3752
+            3758:3102(ResType) ImageSparseFetch 3757 3754 Lod 3756
+            3759:    7(fvec4) CompositeExtract 3758 1
+                              Store 3742(texel) 3759
+            3760:     47(int) CompositeExtract 3758 0
+            3761:         357 Load 359(s2DRect)
+            3762:   53(fvec2) Load 148(c2)
+            3763:  721(ivec2) ConvertFToS 3762
+            3764:         356 Image 3761
+            3765:3102(ResType) ImageSparseFetch 3764 3763
+            3766:    7(fvec4) CompositeExtract 3765 1
+                              Store 3742(texel) 3766
+            3767:     47(int) CompositeExtract 3765 0
+            3768:         284 Load 286(s2DArray)
+            3769:  167(fvec3) Load 169(c3)
+            3770:  734(ivec3) ConvertFToS 3769
+            3771:   52(float) Load 565(lod)
+            3772:     47(int) ConvertFToS 3771
+            3773:         283 Image 3768
+            3774:3102(ResType) ImageSparseFetch 3773 3770 Lod 3772
+            3775:    7(fvec4) CompositeExtract 3774 1
+                              Store 3742(texel) 3775
+            3776:     47(int) CompositeExtract 3774 0
+            3777:        1309 Load 1311(s2DMS)
+            3778:   53(fvec2) Load 148(c2)
+            3779:  721(ivec2) ConvertFToS 3778
+            3780:        1308 Image 3777
+            3781:3102(ResType) ImageSparseFetch 3780 3779 Sample 709
+            3782:    7(fvec4) CompositeExtract 3781 1
+                              Store 3742(texel) 3782
+            3783:     47(int) CompositeExtract 3781 0
+            3784:        1320 Load 1322(s2DMSArray)
+            3785:  167(fvec3) Load 169(c3)
+            3786:  734(ivec3) ConvertFToS 3785
+            3787:        1319 Image 3784
+            3788:3102(ResType) ImageSparseFetch 3787 3786 Sample 1326
+            3789:    7(fvec4) CompositeExtract 3788 1
+                              Store 3742(texel) 3789
+            3790:     47(int) CompositeExtract 3788 0
+            3791:    7(fvec4) Load 3742(texel)
+                              ReturnValue 3791
+                              FunctionEnd
+83(testSparseTexelFetchOffset():    7(fvec4) Function None 8
+              84:             Label
+     3794(texel):     64(ptr) Variable Function
+                              Store 3794(texel) 121
+            3795:         143 Load 145(s2D)
+            3796:   53(fvec2) Load 148(c2)
+            3797:  721(ivec2) ConvertFToS 3796
+            3798:   52(float) Load 565(lod)
+            3799:     47(int) ConvertFToS 3798
+            3800:         142 Image 3795
+            3801:3102(ResType) ImageSparseFetch 3800 3797 Lod ConstOffset 3799 722
+            3802:    7(fvec4) CompositeExtract 3801 1
+                              Store 3794(texel) 3802
+            3803:     47(int) CompositeExtract 3801 0
+            3804:         163 Load 165(s3D)
+            3805:  167(fvec3) Load 169(c3)
+            3806:  734(ivec3) ConvertFToS 3805
+            3807:   52(float) Load 565(lod)
+            3808:     47(int) ConvertFToS 3807
+            3809:         162 Image 3804
+            3810:3102(ResType) ImageSparseFetch 3809 3806 Lod ConstOffset 3808 735
+            3811:    7(fvec4) CompositeExtract 3810 1
+                              Store 3794(texel) 3811
+            3812:     47(int) CompositeExtract 3810 0
+            3813:         357 Load 359(s2DRect)
+            3814:   53(fvec2) Load 148(c2)
+            3815:  721(ivec2) ConvertFToS 3814
+            3816:         356 Image 3813
+            3817:3102(ResType) ImageSparseFetch 3816 3815 ConstOffset 722
+            3818:    7(fvec4) CompositeExtract 3817 1
+                              Store 3794(texel) 3818
+            3819:     47(int) CompositeExtract 3817 0
+            3820:         284 Load 286(s2DArray)
+            3821:  167(fvec3) Load 169(c3)
+            3822:  734(ivec3) ConvertFToS 3821
+            3823:   52(float) Load 565(lod)
+            3824:     47(int) ConvertFToS 3823
+            3825:         283 Image 3820
+            3826:3102(ResType) ImageSparseFetch 3825 3822 Lod ConstOffset 3824 722
+            3827:    7(fvec4) CompositeExtract 3826 1
+                              Store 3794(texel) 3827
+            3828:     47(int) CompositeExtract 3826 0
+            3829:    7(fvec4) Load 3794(texel)
+                              ReturnValue 3829
+                              FunctionEnd
+85(testSparseTextureGather():    7(fvec4) Function None 8
+              86:             Label
+     3832(texel):     64(ptr) Variable Function
+                              Store 3832(texel) 121
+            3833:         143 Load 145(s2D)
+            3834:   53(fvec2) Load 148(c2)
+            3835:3102(ResType) ImageSparseGather 3833 3834 2187
+            3836:    7(fvec4) CompositeExtract 3835 1
+                              Store 3832(texel) 3836
+            3837:     47(int) CompositeExtract 3835 0
+            3838:         143 Load 145(s2D)
+            3839:  154(fvec2) Load 156(f16c2)
+            3840:    6(float) Load 137(f16bias)
+            3841:3102(ResType) ImageSparseGather 3838 3839 2187 Bias 3840
+            3842:    7(fvec4) CompositeExtract 3841 1
+                              Store 3832(texel) 3842
+            3843:     47(int) CompositeExtract 3841 0
+            3844:         284 Load 286(s2DArray)
+            3845:  167(fvec3) Load 169(c3)
+            3846:3102(ResType) ImageSparseGather 3844 3845 2187
+            3847:    7(fvec4) CompositeExtract 3846 1
+                              Store 3832(texel) 3847
+            3848:     47(int) CompositeExtract 3846 0
+            3849:         284 Load 286(s2DArray)
+            3850:  175(fvec3) Load 177(f16c3)
+            3851:    6(float) Load 137(f16bias)
+            3852:3102(ResType) ImageSparseGather 3849 3850 2187 Bias 3851
+            3853:    7(fvec4) CompositeExtract 3852 1
+                              Store 3832(texel) 3853
+            3854:     47(int) CompositeExtract 3852 0
+            3855:         184 Load 186(sCube)
+            3856:  167(fvec3) Load 169(c3)
+            3857:3102(ResType) ImageSparseGather 3855 3856 2187
+            3858:    7(fvec4) CompositeExtract 3857 1
+                              Store 3832(texel) 3858
+            3859:     47(int) CompositeExtract 3857 0
+            3860:         184 Load 186(sCube)
+            3861:  175(fvec3) Load 177(f16c3)
+            3862:    6(float) Load 137(f16bias)
+            3863:3102(ResType) ImageSparseGather 3860 3861 2187 Bias 3862
+            3864:    7(fvec4) CompositeExtract 3863 1
+                              Store 3832(texel) 3864
+            3865:     47(int) CompositeExtract 3863 0
+            3866:         299 Load 301(sCubeArray)
+            3867:  249(fvec4) Load 251(c4)
+            3868:3102(ResType) ImageSparseGather 3866 3867 2187
+            3869:    7(fvec4) CompositeExtract 3868 1
+                              Store 3832(texel) 3869
+            3870:     47(int) CompositeExtract 3868 0
+            3871:         299 Load 301(sCubeArray)
+            3872:    7(fvec4) Load 309(f16c4)
+            3873:    6(float) Load 137(f16bias)
+            3874:3102(ResType) ImageSparseGather 3871 3872 2187 Bias 3873
+            3875:    7(fvec4) CompositeExtract 3874 1
+                              Store 3832(texel) 3875
+            3876:     47(int) CompositeExtract 3874 0
+            3877:         357 Load 359(s2DRect)
+            3878:   53(fvec2) Load 148(c2)
+            3879:3102(ResType) ImageSparseGather 3877 3878 2187
+            3880:    7(fvec4) CompositeExtract 3879 1
+                              Store 3832(texel) 3880
+            3881:     47(int) CompositeExtract 3879 0
+            3882:         357 Load 359(s2DRect)
+            3883:  154(fvec2) Load 156(f16c2)
+            3884:3102(ResType) ImageSparseGather 3882 3883 2187
+            3885:    7(fvec4) CompositeExtract 3884 1
+                              Store 3832(texel) 3885
+            3886:     47(int) CompositeExtract 3884 0
+            3887:         224 Load 226(s2DShadow)
+            3888:   53(fvec2) Load 148(c2)
+            3889:   52(float) Load 215(compare)
+            3890:3102(ResType) ImageSparseDrefGather 3887 3888 3889
+            3891:    7(fvec4) CompositeExtract 3890 1
+                              Store 3832(texel) 3891
+            3892:     47(int) CompositeExtract 3890 0
+            3893:         224 Load 226(s2DShadow)
+            3894:  154(fvec2) Load 156(f16c2)
+            3895:   52(float) Load 215(compare)
+            3896:3102(ResType) ImageSparseDrefGather 3893 3894 3895
+            3897:    7(fvec4) CompositeExtract 3896 1
+                              Store 3832(texel) 3897
+            3898:     47(int) CompositeExtract 3896 0
+            3899:         337 Load 339(s2DArrayShadow)
+            3900:  167(fvec3) Load 169(c3)
+            3901:   52(float) Load 215(compare)
+            3902:3102(ResType) ImageSparseDrefGather 3899 3900 3901
+            3903:    7(fvec4) CompositeExtract 3902 1
+                              Store 3832(texel) 3903
+            3904:     47(int) CompositeExtract 3902 0
+            3905:         337 Load 339(s2DArrayShadow)
+            3906:  175(fvec3) Load 177(f16c3)
+            3907:   52(float) Load 215(compare)
+            3908:3102(ResType) ImageSparseDrefGather 3905 3906 3907
+            3909:    7(fvec4) CompositeExtract 3908 1
+                              Store 3832(texel) 3909
+            3910:     47(int) CompositeExtract 3908 0
+            3911:         245 Load 247(sCubeShadow)
+            3912:  167(fvec3) Load 169(c3)
+            3913:   52(float) Load 215(compare)
+            3914:3102(ResType) ImageSparseDrefGather 3911 3912 3913
+            3915:    7(fvec4) CompositeExtract 3914 1
+                              Store 3832(texel) 3915
+            3916:     47(int) CompositeExtract 3914 0
+            3917:         245 Load 247(sCubeShadow)
+            3918:  175(fvec3) Load 177(f16c3)
+            3919:   52(float) Load 215(compare)
+            3920:3102(ResType) ImageSparseDrefGather 3917 3918 3919
+            3921:    7(fvec4) CompositeExtract 3920 1
+                              Store 3832(texel) 3921
+            3922:     47(int) CompositeExtract 3920 0
+            3923:         391 Load 393(sCubeArrayShadow)
+            3924:  249(fvec4) Load 251(c4)
+            3925:   52(float) Load 215(compare)
+            3926:3102(ResType) ImageSparseDrefGather 3923 3924 3925
+            3927:    7(fvec4) CompositeExtract 3926 1
+                              Store 3832(texel) 3927
+            3928:     47(int) CompositeExtract 3926 0
+            3929:         391 Load 393(sCubeArrayShadow)
+            3930:    7(fvec4) Load 309(f16c4)
+            3931:   52(float) Load 215(compare)
+            3932:3102(ResType) ImageSparseDrefGather 3929 3930 3931
+            3933:    7(fvec4) CompositeExtract 3932 1
+                              Store 3832(texel) 3933
+            3934:     47(int) CompositeExtract 3932 0
+            3935:         371 Load 373(s2DRectShadow)
+            3936:   53(fvec2) Load 148(c2)
+            3937:   52(float) Load 215(compare)
+            3938:3102(ResType) ImageSparseDrefGather 3935 3936 3937
+            3939:    7(fvec4) CompositeExtract 3938 1
+                              Store 3832(texel) 3939
+            3940:     47(int) CompositeExtract 3938 0
+            3941:         371 Load 373(s2DRectShadow)
+            3942:  154(fvec2) Load 156(f16c2)
+            3943:   52(float) Load 215(compare)
+            3944:3102(ResType) ImageSparseDrefGather 3941 3942 3943
+            3945:    7(fvec4) CompositeExtract 3944 1
+                              Store 3832(texel) 3945
+            3946:     47(int) CompositeExtract 3944 0
+            3947:    7(fvec4) Load 3832(texel)
+                              ReturnValue 3947
+                              FunctionEnd
+87(testSparseTextureGatherOffset():    7(fvec4) Function None 8
+              88:             Label
+     3950(texel):     64(ptr) Variable Function
+                              Store 3950(texel) 121
+            3951:         143 Load 145(s2D)
+            3952:   53(fvec2) Load 148(c2)
+            3953:3102(ResType) ImageSparseGather 3951 3952 2187 ConstOffset 722
+            3954:    7(fvec4) CompositeExtract 3953 1
+                              Store 3950(texel) 3954
+            3955:     47(int) CompositeExtract 3953 0
+            3956:         143 Load 145(s2D)
+            3957:  154(fvec2) Load 156(f16c2)
+            3958:    6(float) Load 137(f16bias)
+            3959:3102(ResType) ImageSparseGather 3956 3957 2187 Bias ConstOffset 3958 722
+            3960:    7(fvec4) CompositeExtract 3959 1
+                              Store 3950(texel) 3960
+            3961:     47(int) CompositeExtract 3959 0
+            3962:         284 Load 286(s2DArray)
+            3963:  167(fvec3) Load 169(c3)
+            3964:3102(ResType) ImageSparseGather 3962 3963 2187 ConstOffset 722
+            3965:    7(fvec4) CompositeExtract 3964 1
+                              Store 3950(texel) 3965
+            3966:     47(int) CompositeExtract 3964 0
+            3967:         284 Load 286(s2DArray)
+            3968:  175(fvec3) Load 177(f16c3)
+            3969:    6(float) Load 137(f16bias)
+            3970:3102(ResType) ImageSparseGather 3967 3968 2187 Bias ConstOffset 3969 722
+            3971:    7(fvec4) CompositeExtract 3970 1
+                              Store 3950(texel) 3971
+            3972:     47(int) CompositeExtract 3970 0
+            3973:         357 Load 359(s2DRect)
+            3974:   53(fvec2) Load 148(c2)
+            3975:3102(ResType) ImageSparseGather 3973 3974 2187 ConstOffset 722
+            3976:    7(fvec4) CompositeExtract 3975 1
+                              Store 3950(texel) 3976
+            3977:     47(int) CompositeExtract 3975 0
+            3978:         357 Load 359(s2DRect)
+            3979:  154(fvec2) Load 156(f16c2)
+            3980:3102(ResType) ImageSparseGather 3978 3979 2187 ConstOffset 722
+            3981:    7(fvec4) CompositeExtract 3980 1
+                              Store 3950(texel) 3981
+            3982:     47(int) CompositeExtract 3980 0
+            3983:         224 Load 226(s2DShadow)
+            3984:   53(fvec2) Load 148(c2)
+            3985:   52(float) Load 215(compare)
+            3986:3102(ResType) ImageSparseDrefGather 3983 3984 3985 ConstOffset 722
+            3987:    7(fvec4) CompositeExtract 3986 1
+                              Store 3950(texel) 3987
+            3988:     47(int) CompositeExtract 3986 0
+            3989:         224 Load 226(s2DShadow)
+            3990:  154(fvec2) Load 156(f16c2)
+            3991:   52(float) Load 215(compare)
+            3992:3102(ResType) ImageSparseDrefGather 3989 3990 3991 ConstOffset 722
+            3993:    7(fvec4) CompositeExtract 3992 1
+                              Store 3950(texel) 3993
+            3994:     47(int) CompositeExtract 3992 0
+            3995:         337 Load 339(s2DArrayShadow)
+            3996:  167(fvec3) Load 169(c3)
+            3997:   52(float) Load 215(compare)
+            3998:3102(ResType) ImageSparseDrefGather 3995 3996 3997 ConstOffset 722
+            3999:    7(fvec4) CompositeExtract 3998 1
+                              Store 3950(texel) 3999
+            4000:     47(int) CompositeExtract 3998 0
+            4001:         337 Load 339(s2DArrayShadow)
+            4002:  175(fvec3) Load 177(f16c3)
+            4003:   52(float) Load 215(compare)
+            4004:3102(ResType) ImageSparseDrefGather 4001 4002 4003 ConstOffset 722
+            4005:    7(fvec4) CompositeExtract 4004 1
+                              Store 3950(texel) 4005
+            4006:     47(int) CompositeExtract 4004 0
+            4007:         371 Load 373(s2DRectShadow)
+            4008:   53(fvec2) Load 148(c2)
+            4009:   52(float) Load 215(compare)
+            4010:3102(ResType) ImageSparseDrefGather 4007 4008 4009 ConstOffset 722
+            4011:    7(fvec4) CompositeExtract 4010 1
+                              Store 3950(texel) 4011
+            4012:     47(int) CompositeExtract 4010 0
+            4013:         371 Load 373(s2DRectShadow)
+            4014:  154(fvec2) Load 156(f16c2)
+            4015:   52(float) Load 215(compare)
+            4016:3102(ResType) ImageSparseDrefGather 4013 4014 4015 ConstOffset 722
+            4017:    7(fvec4) CompositeExtract 4016 1
+                              Store 3950(texel) 4017
+            4018:     47(int) CompositeExtract 4016 0
+            4019:    7(fvec4) Load 3950(texel)
+                              ReturnValue 4019
+                              FunctionEnd
+89(testSparseTextureGatherOffsets():    7(fvec4) Function None 8
+              90:             Label
+     4022(texel):     64(ptr) Variable Function
+                              Store 4022(texel) 121
+            4023:         143 Load 145(s2D)
+            4024:   53(fvec2) Load 148(c2)
+            4025:3102(ResType) ImageSparseGather 4023 4024 2187 ConstOffsets 2380
+            4026:    7(fvec4) CompositeExtract 4025 1
+                              Store 4022(texel) 4026
+            4027:     47(int) CompositeExtract 4025 0
+            4028:         143 Load 145(s2D)
+            4029:  154(fvec2) Load 156(f16c2)
+            4030:    6(float) Load 137(f16bias)
+            4031:3102(ResType) ImageSparseGather 4028 4029 2187 Bias ConstOffsets 4030 2380
+            4032:    7(fvec4) CompositeExtract 4031 1
+                              Store 4022(texel) 4032
+            4033:     47(int) CompositeExtract 4031 0
+            4034:         284 Load 286(s2DArray)
+            4035:  167(fvec3) Load 169(c3)
+            4036:3102(ResType) ImageSparseGather 4034 4035 2187 ConstOffsets 2380
+            4037:    7(fvec4) CompositeExtract 4036 1
+                              Store 4022(texel) 4037
+            4038:     47(int) CompositeExtract 4036 0
+            4039:         284 Load 286(s2DArray)
+            4040:  175(fvec3) Load 177(f16c3)
+            4041:    6(float) Load 137(f16bias)
+            4042:3102(ResType) ImageSparseGather 4039 4040 2187 Bias ConstOffsets 4041 2380
+            4043:    7(fvec4) CompositeExtract 4042 1
+                              Store 4022(texel) 4043
+            4044:     47(int) CompositeExtract 4042 0
+            4045:         357 Load 359(s2DRect)
+            4046:   53(fvec2) Load 148(c2)
+            4047:3102(ResType) ImageSparseGather 4045 4046 2187 ConstOffsets 2380
+            4048:    7(fvec4) CompositeExtract 4047 1
+                              Store 4022(texel) 4048
+            4049:     47(int) CompositeExtract 4047 0
+            4050:         357 Load 359(s2DRect)
+            4051:  154(fvec2) Load 156(f16c2)
+            4052:3102(ResType) ImageSparseGather 4050 4051 2187 ConstOffsets 2380
+            4053:    7(fvec4) CompositeExtract 4052 1
+                              Store 4022(texel) 4053
+            4054:     47(int) CompositeExtract 4052 0
+            4055:         224 Load 226(s2DShadow)
+            4056:   53(fvec2) Load 148(c2)
+            4057:   52(float) Load 215(compare)
+            4058:3102(ResType) ImageSparseDrefGather 4055 4056 4057 ConstOffsets 2380
+            4059:    7(fvec4) CompositeExtract 4058 1
+                              Store 4022(texel) 4059
+            4060:     47(int) CompositeExtract 4058 0
+            4061:         224 Load 226(s2DShadow)
+            4062:  154(fvec2) Load 156(f16c2)
+            4063:   52(float) Load 215(compare)
+            4064:3102(ResType) ImageSparseDrefGather 4061 4062 4063 ConstOffsets 2380
+            4065:    7(fvec4) CompositeExtract 4064 1
+                              Store 4022(texel) 4065
+            4066:     47(int) CompositeExtract 4064 0
+            4067:         337 Load 339(s2DArrayShadow)
+            4068:  167(fvec3) Load 169(c3)
+            4069:   52(float) Load 215(compare)
+            4070:3102(ResType) ImageSparseDrefGather 4067 4068 4069 ConstOffsets 2380
+            4071:    7(fvec4) CompositeExtract 4070 1
+                              Store 4022(texel) 4071
+            4072:     47(int) CompositeExtract 4070 0
+            4073:         337 Load 339(s2DArrayShadow)
+            4074:  175(fvec3) Load 177(f16c3)
+            4075:   52(float) Load 215(compare)
+            4076:3102(ResType) ImageSparseDrefGather 4073 4074 4075 ConstOffsets 2380
+            4077:    7(fvec4) CompositeExtract 4076 1
+                              Store 4022(texel) 4077
+            4078:     47(int) CompositeExtract 4076 0
+            4079:         371 Load 373(s2DRectShadow)
+            4080:   53(fvec2) Load 148(c2)
+            4081:   52(float) Load 215(compare)
+            4082:3102(ResType) ImageSparseDrefGather 4079 4080 4081 ConstOffsets 2380
+            4083:    7(fvec4) CompositeExtract 4082 1
+                              Store 4022(texel) 4083
+            4084:     47(int) CompositeExtract 4082 0
+            4085:         371 Load 373(s2DRectShadow)
+            4086:  154(fvec2) Load 156(f16c2)
+            4087:   52(float) Load 215(compare)
+            4088:3102(ResType) ImageSparseDrefGather 4085 4086 4087 ConstOffsets 2380
+            4089:    7(fvec4) CompositeExtract 4088 1
+                              Store 4022(texel) 4089
+            4090:     47(int) CompositeExtract 4088 0
+            4091:    7(fvec4) Load 4022(texel)
+                              ReturnValue 4091
+                              FunctionEnd
+91(testSparseTextureGatherLod():    7(fvec4) Function None 8
+              92:             Label
+     4094(texel):     64(ptr) Variable Function
+                              Store 4094(texel) 121
+            4095:         143 Load 145(s2D)
+            4096:   53(fvec2) Load 148(c2)
+            4097:   52(float) Load 565(lod)
+            4098:3102(ResType) ImageSparseGather 4095 4096 2187 Lod 4097
+            4099:    7(fvec4) CompositeExtract 4098 1
+                              Store 4094(texel) 4099
+            4100:     47(int) CompositeExtract 4098 0
+            4101:         143 Load 145(s2D)
+            4102:  154(fvec2) Load 156(f16c2)
+            4103:    6(float) Load 572(f16lod)
+            4104:3102(ResType) ImageSparseGather 4101 4102 2187 Lod 4103
+            4105:    7(fvec4) CompositeExtract 4104 1
+                              Store 4094(texel) 4105
+            4106:     47(int) CompositeExtract 4104 0
+            4107:         284 Load 286(s2DArray)
+            4108:  167(fvec3) Load 169(c3)
+            4109:   52(float) Load 565(lod)
+            4110:3102(ResType) ImageSparseGather 4107 4108 2187 Lod 4109
+            4111:    7(fvec4) CompositeExtract 4110 1
+                              Store 4094(texel) 4111
+            4112:     47(int) CompositeExtract 4110 0
+            4113:         284 Load 286(s2DArray)
+            4114:  175(fvec3) Load 177(f16c3)
+            4115:    6(float) Load 572(f16lod)
+            4116:3102(ResType) ImageSparseGather 4113 4114 2187 Lod 4115
+            4117:    7(fvec4) CompositeExtract 4116 1
+                              Store 4094(texel) 4117
+            4118:     47(int) CompositeExtract 4116 0
+            4119:         184 Load 186(sCube)
+            4120:  167(fvec3) Load 169(c3)
+            4121:   52(float) Load 565(lod)
+            4122:3102(ResType) ImageSparseGather 4119 4120 2187 Lod 4121
+            4123:    7(fvec4) CompositeExtract 4122 1
+                              Store 4094(texel) 4123
+            4124:     47(int) CompositeExtract 4122 0
+            4125:         184 Load 186(sCube)
+            4126:  175(fvec3) Load 177(f16c3)
+            4127:    6(float) Load 572(f16lod)
+            4128:3102(ResType) ImageSparseGather 4125 4126 2187 Lod 4127
+            4129:    7(fvec4) CompositeExtract 4128 1
+                              Store 4094(texel) 4129
+            4130:     47(int) CompositeExtract 4128 0
+            4131:         299 Load 301(sCubeArray)
+            4132:  249(fvec4) Load 251(c4)
+            4133:   52(float) Load 565(lod)
+            4134:3102(ResType) ImageSparseGather 4131 4132 2187 Lod 4133
+            4135:    7(fvec4) CompositeExtract 4134 1
+                              Store 4094(texel) 4135
+            4136:     47(int) CompositeExtract 4134 0
+            4137:         299 Load 301(sCubeArray)
+            4138:    7(fvec4) Load 309(f16c4)
+            4139:    6(float) Load 572(f16lod)
+            4140:3102(ResType) ImageSparseGather 4137 4138 2187 Lod 4139
+            4141:    7(fvec4) CompositeExtract 4140 1
+                              Store 4094(texel) 4141
+            4142:     47(int) CompositeExtract 4140 0
+            4143:    7(fvec4) Load 4094(texel)
+                              ReturnValue 4143
+                              FunctionEnd
+93(testSparseTextureGatherLodOffset():    7(fvec4) Function None 8
+              94:             Label
+     4146(texel):     64(ptr) Variable Function
+                              Store 4146(texel) 121
+            4147:         143 Load 145(s2D)
+            4148:   53(fvec2) Load 148(c2)
+            4149:   52(float) Load 565(lod)
+            4150:3102(ResType) ImageSparseGather 4147 4148 2187 Lod ConstOffset 4149 722
+            4151:    7(fvec4) CompositeExtract 4150 1
+                              Store 4146(texel) 4151
+            4152:     47(int) CompositeExtract 4150 0
+            4153:         143 Load 145(s2D)
+            4154:  154(fvec2) Load 156(f16c2)
+            4155:    6(float) Load 572(f16lod)
+            4156:3102(ResType) ImageSparseGather 4153 4154 2187 Lod ConstOffset 4155 722
+            4157:    7(fvec4) CompositeExtract 4156 1
+                              Store 4146(texel) 4157
+            4158:     47(int) CompositeExtract 4156 0
+            4159:         284 Load 286(s2DArray)
+            4160:  167(fvec3) Load 169(c3)
+            4161:   52(float) Load 565(lod)
+            4162:3102(ResType) ImageSparseGather 4159 4160 2187 Lod ConstOffset 4161 722
+            4163:    7(fvec4) CompositeExtract 4162 1
+                              Store 4146(texel) 4163
+            4164:     47(int) CompositeExtract 4162 0
+            4165:         284 Load 286(s2DArray)
+            4166:  175(fvec3) Load 177(f16c3)
+            4167:    6(float) Load 572(f16lod)
+            4168:3102(ResType) ImageSparseGather 4165 4166 2187 Lod ConstOffset 4167 722
+            4169:    7(fvec4) CompositeExtract 4168 1
+                              Store 4146(texel) 4169
+            4170:     47(int) CompositeExtract 4168 0
+            4171:    7(fvec4) Load 4146(texel)
+                              ReturnValue 4171
+                              FunctionEnd
+95(testSparseTextureGatherLodOffsets():    7(fvec4) Function None 8
+              96:             Label
+     4174(texel):     64(ptr) Variable Function
+                              Store 4174(texel) 121
+            4175:         143 Load 145(s2D)
+            4176:   53(fvec2) Load 148(c2)
+            4177:   52(float) Load 565(lod)
+            4178:3102(ResType) ImageSparseGather 4175 4176 2187 Lod ConstOffsets 4177 2380
+            4179:    7(fvec4) CompositeExtract 4178 1
+                              Store 4174(texel) 4179
+            4180:     47(int) CompositeExtract 4178 0
+            4181:         143 Load 145(s2D)
+            4182:  154(fvec2) Load 156(f16c2)
+            4183:    6(float) Load 572(f16lod)
+            4184:3102(ResType) ImageSparseGather 4181 4182 2187 Lod ConstOffsets 4183 2380
+            4185:    7(fvec4) CompositeExtract 4184 1
+                              Store 4174(texel) 4185
+            4186:     47(int) CompositeExtract 4184 0
+            4187:         284 Load 286(s2DArray)
+            4188:  167(fvec3) Load 169(c3)
+            4189:   52(float) Load 565(lod)
+            4190:3102(ResType) ImageSparseGather 4187 4188 2187 Lod ConstOffsets 4189 2380
+            4191:    7(fvec4) CompositeExtract 4190 1
+                              Store 4174(texel) 4191
+            4192:     47(int) CompositeExtract 4190 0
+            4193:         284 Load 286(s2DArray)
+            4194:  175(fvec3) Load 177(f16c3)
+            4195:    6(float) Load 572(f16lod)
+            4196:3102(ResType) ImageSparseGather 4193 4194 2187 Lod ConstOffsets 4195 2380
+            4197:    7(fvec4) CompositeExtract 4196 1
+                              Store 4174(texel) 4197
+            4198:     47(int) CompositeExtract 4196 0
+            4199:    7(fvec4) Load 4174(texel)
+                              ReturnValue 4199
+                              FunctionEnd
+97(testSparseImageLoad():    7(fvec4) Function None 8
+              98:             Label
+     4202(texel):     64(ptr) Variable Function
+                              Store 4202(texel) 121
+            4203:        2962 Load 2964(i2D)
+            4204:   53(fvec2) Load 148(c2)
+            4205:  721(ivec2) ConvertFToS 4204
+            4206:3102(ResType) ImageSparseRead 4203 4205
+            4207:    7(fvec4) CompositeExtract 4206 1
+                              Store 4202(texel) 4207
+            4208:     47(int) CompositeExtract 4206 0
+            4209:        2971 Load 2973(i3D)
+            4210:  167(fvec3) Load 169(c3)
+            4211:  734(ivec3) ConvertFToS 4210
+            4212:3102(ResType) ImageSparseRead 4209 4211
+            4213:    7(fvec4) CompositeExtract 4212 1
+                              Store 4202(texel) 4213
+            4214:     47(int) CompositeExtract 4212 0
+            4215:        2980 Load 2982(i2DRect)
+            4216:   53(fvec2) Load 148(c2)
+            4217:  721(ivec2) ConvertFToS 4216
+            4218:3102(ResType) ImageSparseRead 4215 4217
+            4219:    7(fvec4) CompositeExtract 4218 1
+                              Store 4202(texel) 4219
+            4220:     47(int) CompositeExtract 4218 0
+            4221:        2989 Load 2991(iCube)
+            4222:  167(fvec3) Load 169(c3)
+            4223:  734(ivec3) ConvertFToS 4222
+            4224:3102(ResType) ImageSparseRead 4221 4223
+            4225:    7(fvec4) CompositeExtract 4224 1
+                              Store 4202(texel) 4225
+            4226:     47(int) CompositeExtract 4224 0
+            4227:        3016 Load 3018(i2DArray)
+            4228:  167(fvec3) Load 169(c3)
+            4229:  734(ivec3) ConvertFToS 4228
+            4230:3102(ResType) ImageSparseRead 4227 4229
+            4231:    7(fvec4) CompositeExtract 4230 1
+                              Store 4202(texel) 4231
+            4232:     47(int) CompositeExtract 4230 0
+            4233:        3025 Load 3027(iCubeArray)
+            4234:  167(fvec3) Load 169(c3)
+            4235:  734(ivec3) ConvertFToS 4234
+            4236:3102(ResType) ImageSparseRead 4233 4235
+            4237:    7(fvec4) CompositeExtract 4236 1
+                              Store 4202(texel) 4237
+            4238:     47(int) CompositeExtract 4236 0
+            4239:        3034 Load 3036(i2DMS)
+            4240:   53(fvec2) Load 148(c2)
+            4241:  721(ivec2) ConvertFToS 4240
+            4242:3102(ResType) ImageSparseRead 4239 4241 Sample 709
+            4243:    7(fvec4) CompositeExtract 4242 1
+                              Store 4202(texel) 4243
+            4244:     47(int) CompositeExtract 4242 0
+            4245:        3043 Load 3045(i2DMSArray)
+            4246:  167(fvec3) Load 169(c3)
+            4247:  734(ivec3) ConvertFToS 4246
+            4248:3102(ResType) ImageSparseRead 4245 4247 Sample 1326
+            4249:    7(fvec4) CompositeExtract 4248 1
+                              Store 4202(texel) 4249
+            4250:     47(int) CompositeExtract 4248 0
+            4251:    7(fvec4) Load 4202(texel)
+                              ReturnValue 4251
+                              FunctionEnd
+99(testSparseTextureClamp():    7(fvec4) Function None 8
+             100:             Label
+     4254(texel):     64(ptr) Variable Function
+                              Store 4254(texel) 121
+            4255:         143 Load 145(s2D)
+            4256:   53(fvec2) Load 148(c2)
+            4258:   52(float) Load 4257(lodClamp)
+            4259:3102(ResType) ImageSparseSampleImplicitLod 4255 4256 MinLod 4258
+            4260:    7(fvec4) CompositeExtract 4259 1
+                              Store 4254(texel) 4260
+            4261:     47(int) CompositeExtract 4259 0
+            4262:         143 Load 145(s2D)
+            4263:  154(fvec2) Load 156(f16c2)
+            4265:    6(float) Load 4264(f16lodClamp)
+            4266:    6(float) Load 137(f16bias)
+            4267:3102(ResType) ImageSparseSampleImplicitLod 4262 4263 Bias MinLod 4266 4265
+            4268:    7(fvec4) CompositeExtract 4267 1
+                              Store 4254(texel) 4268
+            4269:     47(int) CompositeExtract 4267 0
+            4270:         163 Load 165(s3D)
+            4271:  167(fvec3) Load 169(c3)
+            4272:   52(float) Load 4257(lodClamp)
+            4273:3102(ResType) ImageSparseSampleImplicitLod 4270 4271 MinLod 4272
+            4274:    7(fvec4) CompositeExtract 4273 1
+                              Store 4254(texel) 4274
+            4275:     47(int) CompositeExtract 4273 0
+            4276:         163 Load 165(s3D)
+            4277:  175(fvec3) Load 177(f16c3)
+            4278:    6(float) Load 4264(f16lodClamp)
+            4279:    6(float) Load 137(f16bias)
+            4280:3102(ResType) ImageSparseSampleImplicitLod 4276 4277 Bias MinLod 4279 4278
+            4281:    7(fvec4) CompositeExtract 4280 1
+                              Store 4254(texel) 4281
+            4282:     47(int) CompositeExtract 4280 0
+            4283:         184 Load 186(sCube)
+            4284:  167(fvec3) Load 169(c3)
+            4285:   52(float) Load 4257(lodClamp)
+            4286:3102(ResType) ImageSparseSampleImplicitLod 4283 4284 MinLod 4285
+            4287:    7(fvec4) CompositeExtract 4286 1
+                              Store 4254(texel) 4287
+            4288:     47(int) CompositeExtract 4286 0
+            4289:         184 Load 186(sCube)
+            4290:  175(fvec3) Load 177(f16c3)
+            4291:    6(float) Load 4264(f16lodClamp)
+            4292:    6(float) Load 137(f16bias)
+            4293:3102(ResType) ImageSparseSampleImplicitLod 4289 4290 Bias MinLod 4292 4291
+            4294:    7(fvec4) CompositeExtract 4293 1
+                              Store 4254(texel) 4294
+            4295:     47(int) CompositeExtract 4293 0
+            4296:         224 Load 226(s2DShadow)
+            4297:  167(fvec3) Load 169(c3)
+            4298:   52(float) Load 4257(lodClamp)
+            4299:    208(ptr) AccessChain 4254(texel) 207
+            4300:   52(float) CompositeExtract 4297 2
+            4301:3138(ResType) ImageSparseSampleDrefImplicitLod 4296 4297 4300 MinLod 4298
+            4302:    6(float) CompositeExtract 4301 1
+                              Store 4299 4302
+            4303:     47(int) CompositeExtract 4301 0
+            4304:         224 Load 226(s2DShadow)
+            4305:  154(fvec2) Load 156(f16c2)
+            4306:   52(float) Load 215(compare)
+            4307:    6(float) Load 4264(f16lodClamp)
+            4308:    208(ptr) AccessChain 4254(texel) 207
+            4309:    6(float) Load 137(f16bias)
+            4310:3138(ResType) ImageSparseSampleDrefImplicitLod 4304 4305 4306 Bias MinLod 4309 4307
+            4311:    6(float) CompositeExtract 4310 1
+                              Store 4308 4311
+            4312:     47(int) CompositeExtract 4310 0
+            4313:         245 Load 247(sCubeShadow)
+            4314:  249(fvec4) Load 251(c4)
+            4315:   52(float) Load 4257(lodClamp)
+            4316:    208(ptr) AccessChain 4254(texel) 207
+            4317:   52(float) CompositeExtract 4314 3
+            4318:3138(ResType) ImageSparseSampleDrefImplicitLod 4313 4314 4317 MinLod 4315
+            4319:    6(float) CompositeExtract 4318 1
+                              Store 4316 4319
+            4320:     47(int) CompositeExtract 4318 0
+            4321:         245 Load 247(sCubeShadow)
+            4322:  175(fvec3) Load 177(f16c3)
+            4323:   52(float) Load 215(compare)
+            4324:    6(float) Load 4264(f16lodClamp)
+            4325:    208(ptr) AccessChain 4254(texel) 207
+            4326:    6(float) Load 137(f16bias)
+            4327:3138(ResType) ImageSparseSampleDrefImplicitLod 4321 4322 4323 Bias MinLod 4326 4324
+            4328:    6(float) CompositeExtract 4327 1
+                              Store 4325 4328
+            4329:     47(int) CompositeExtract 4327 0
+            4330:         284 Load 286(s2DArray)
+            4331:  167(fvec3) Load 169(c3)
+            4332:   52(float) Load 4257(lodClamp)
+            4333:3102(ResType) ImageSparseSampleImplicitLod 4330 4331 MinLod 4332
+            4334:    7(fvec4) CompositeExtract 4333 1
+                              Store 4254(texel) 4334
+            4335:     47(int) CompositeExtract 4333 0
+            4336:         284 Load 286(s2DArray)
+            4337:  175(fvec3) Load 177(f16c3)
+            4338:    6(float) Load 4264(f16lodClamp)
+            4339:    6(float) Load 137(f16bias)
+            4340:3102(ResType) ImageSparseSampleImplicitLod 4336 4337 Bias MinLod 4339 4338
+            4341:    7(fvec4) CompositeExtract 4340 1
+                              Store 4254(texel) 4341
+            4342:     47(int) CompositeExtract 4340 0
+            4343:         299 Load 301(sCubeArray)
+            4344:  249(fvec4) Load 251(c4)
+            4345:   52(float) Load 4257(lodClamp)
+            4346:3102(ResType) ImageSparseSampleImplicitLod 4343 4344 MinLod 4345
+            4347:    7(fvec4) CompositeExtract 4346 1
+                              Store 4254(texel) 4347
+            4348:     47(int) CompositeExtract 4346 0
+            4349:         299 Load 301(sCubeArray)
+            4350:    7(fvec4) Load 309(f16c4)
+            4351:    6(float) Load 4264(f16lodClamp)
+            4352:    6(float) Load 137(f16bias)
+            4353:3102(ResType) ImageSparseSampleImplicitLod 4349 4350 Bias MinLod 4352 4351
+            4354:    7(fvec4) CompositeExtract 4353 1
+                              Store 4254(texel) 4354
+            4355:     47(int) CompositeExtract 4353 0
+            4356:         337 Load 339(s2DArrayShadow)
+            4357:  249(fvec4) Load 251(c4)
+            4358:   52(float) Load 4257(lodClamp)
+            4359:    208(ptr) AccessChain 4254(texel) 207
+            4360:   52(float) CompositeExtract 4357 3
+            4361:3138(ResType) ImageSparseSampleDrefImplicitLod 4356 4357 4360 MinLod 4358
+            4362:    6(float) CompositeExtract 4361 1
+                              Store 4359 4362
+            4363:     47(int) CompositeExtract 4361 0
+            4364:         337 Load 339(s2DArrayShadow)
+            4365:  175(fvec3) Load 177(f16c3)
+            4366:   52(float) Load 215(compare)
+            4367:    6(float) Load 4264(f16lodClamp)
+            4368:    208(ptr) AccessChain 4254(texel) 207
+            4369:3138(ResType) ImageSparseSampleDrefImplicitLod 4364 4365 4366 MinLod 4367
+            4370:    6(float) CompositeExtract 4369 1
+                              Store 4368 4370
+            4371:     47(int) CompositeExtract 4369 0
+            4372:         391 Load 393(sCubeArrayShadow)
+            4373:  249(fvec4) Load 251(c4)
+            4374:   52(float) Load 215(compare)
+            4375:   52(float) Load 4257(lodClamp)
+            4376:    208(ptr) AccessChain 4254(texel) 207
+            4377:3138(ResType) ImageSparseSampleDrefImplicitLod 4372 4373 4374 MinLod 4375
+            4378:    6(float) CompositeExtract 4377 1
+                              Store 4376 4378
+            4379:     47(int) CompositeExtract 4377 0
+            4380:         391 Load 393(sCubeArrayShadow)
+            4381:    7(fvec4) Load 309(f16c4)
+            4382:   52(float) Load 215(compare)
+            4383:    6(float) Load 4264(f16lodClamp)
+            4384:    208(ptr) AccessChain 4254(texel) 207
+            4385:3138(ResType) ImageSparseSampleDrefImplicitLod 4380 4381 4382 MinLod 4383
+            4386:    6(float) CompositeExtract 4385 1
+                              Store 4384 4386
+            4387:     47(int) CompositeExtract 4385 0
+            4388:    7(fvec4) Load 4254(texel)
+                              ReturnValue 4388
+                              FunctionEnd
+101(testTextureClamp():    7(fvec4) Function None 8
+             102:             Label
+     4391(texel):     64(ptr) Variable Function
+                              Store 4391(texel) 121
+            4392:         123 Load 125(s1D)
+            4393:   52(float) Load 128(c1)
+            4394:   52(float) Load 4257(lodClamp)
+            4395:    7(fvec4) ImageSampleImplicitLod 4392 4393 MinLod 4394
+            4396:    7(fvec4) Load 4391(texel)
+            4397:    7(fvec4) FAdd 4396 4395
+                              Store 4391(texel) 4397
+            4398:         123 Load 125(s1D)
+            4399:    6(float) Load 135(f16c1)
+            4400:    6(float) Load 4264(f16lodClamp)
+            4401:    6(float) Load 137(f16bias)
+            4402:    7(fvec4) ImageSampleImplicitLod 4398 4399 Bias MinLod 4401 4400
+            4403:    7(fvec4) Load 4391(texel)
+            4404:    7(fvec4) FAdd 4403 4402
+                              Store 4391(texel) 4404
+            4405:         143 Load 145(s2D)
+            4406:   53(fvec2) Load 148(c2)
+            4407:   52(float) Load 4257(lodClamp)
+            4408:    7(fvec4) ImageSampleImplicitLod 4405 4406 MinLod 4407
+            4409:    7(fvec4) Load 4391(texel)
+            4410:    7(fvec4) FAdd 4409 4408
+                              Store 4391(texel) 4410
+            4411:         143 Load 145(s2D)
+            4412:  154(fvec2) Load 156(f16c2)
+            4413:    6(float) Load 4264(f16lodClamp)
+            4414:    6(float) Load 137(f16bias)
+            4415:    7(fvec4) ImageSampleImplicitLod 4411 4412 Bias MinLod 4414 4413
+            4416:    7(fvec4) Load 4391(texel)
+            4417:    7(fvec4) FAdd 4416 4415
+                              Store 4391(texel) 4417
+            4418:         163 Load 165(s3D)
+            4419:  167(fvec3) Load 169(c3)
+            4420:   52(float) Load 4257(lodClamp)
+            4421:    7(fvec4) ImageSampleImplicitLod 4418 4419 MinLod 4420
+            4422:    7(fvec4) Load 4391(texel)
+            4423:    7(fvec4) FAdd 4422 4421
+                              Store 4391(texel) 4423
+            4424:         163 Load 165(s3D)
+            4425:  175(fvec3) Load 177(f16c3)
+            4426:    6(float) Load 4264(f16lodClamp)
+            4427:    6(float) Load 137(f16bias)
+            4428:    7(fvec4) ImageSampleImplicitLod 4424 4425 Bias MinLod 4427 4426
+            4429:    7(fvec4) Load 4391(texel)
+            4430:    7(fvec4) FAdd 4429 4428
+                              Store 4391(texel) 4430
+            4431:         184 Load 186(sCube)
+            4432:  167(fvec3) Load 169(c3)
+            4433:   52(float) Load 4257(lodClamp)
+            4434:    7(fvec4) ImageSampleImplicitLod 4431 4432 MinLod 4433
+            4435:    7(fvec4) Load 4391(texel)
+            4436:    7(fvec4) FAdd 4435 4434
+                              Store 4391(texel) 4436
+            4437:         184 Load 186(sCube)
+            4438:  175(fvec3) Load 177(f16c3)
+            4439:    6(float) Load 4264(f16lodClamp)
+            4440:    6(float) Load 137(f16bias)
+            4441:    7(fvec4) ImageSampleImplicitLod 4437 4438 Bias MinLod 4440 4439
+            4442:    7(fvec4) Load 4391(texel)
+            4443:    7(fvec4) FAdd 4442 4441
+                              Store 4391(texel) 4443
+            4444:         199 Load 201(s1DShadow)
+            4445:  167(fvec3) Load 169(c3)
+            4446:   52(float) Load 4257(lodClamp)
+            4447:   52(float) CompositeExtract 4445 2
+            4448:    6(float) ImageSampleDrefImplicitLod 4444 4445 4447 MinLod 4446
+            4449:    208(ptr) AccessChain 4391(texel) 207
+            4450:    6(float) Load 4449
+            4451:    6(float) FAdd 4450 4448
+            4452:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4452 4451
+            4453:         199 Load 201(s1DShadow)
+            4454:  154(fvec2) Load 156(f16c2)
+            4455:   52(float) Load 215(compare)
+            4456:    6(float) Load 4264(f16lodClamp)
+            4457:    6(float) Load 137(f16bias)
+            4458:    6(float) ImageSampleDrefImplicitLod 4453 4454 4455 Bias MinLod 4457 4456
+            4459:    208(ptr) AccessChain 4391(texel) 207
+            4460:    6(float) Load 4459
+            4461:    6(float) FAdd 4460 4458
+            4462:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4462 4461
+            4463:         224 Load 226(s2DShadow)
+            4464:  167(fvec3) Load 169(c3)
+            4465:   52(float) Load 4257(lodClamp)
+            4466:   52(float) CompositeExtract 4464 2
+            4467:    6(float) ImageSampleDrefImplicitLod 4463 4464 4466 MinLod 4465
+            4468:    208(ptr) AccessChain 4391(texel) 207
+            4469:    6(float) Load 4468
+            4470:    6(float) FAdd 4469 4467
+            4471:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4471 4470
+            4472:         224 Load 226(s2DShadow)
+            4473:  154(fvec2) Load 156(f16c2)
+            4474:   52(float) Load 215(compare)
+            4475:    6(float) Load 4264(f16lodClamp)
+            4476:    6(float) Load 137(f16bias)
+            4477:    6(float) ImageSampleDrefImplicitLod 4472 4473 4474 Bias MinLod 4476 4475
+            4478:    208(ptr) AccessChain 4391(texel) 207
+            4479:    6(float) Load 4478
+            4480:    6(float) FAdd 4479 4477
+            4481:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4481 4480
+            4482:         245 Load 247(sCubeShadow)
+            4483:  249(fvec4) Load 251(c4)
+            4484:   52(float) Load 4257(lodClamp)
+            4485:   52(float) CompositeExtract 4483 3
+            4486:    6(float) ImageSampleDrefImplicitLod 4482 4483 4485 MinLod 4484
+            4487:    208(ptr) AccessChain 4391(texel) 207
+            4488:    6(float) Load 4487
+            4489:    6(float) FAdd 4488 4486
+            4490:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4490 4489
+            4491:         245 Load 247(sCubeShadow)
+            4492:  175(fvec3) Load 177(f16c3)
+            4493:   52(float) Load 215(compare)
+            4494:    6(float) Load 4264(f16lodClamp)
+            4495:    6(float) Load 137(f16bias)
+            4496:    6(float) ImageSampleDrefImplicitLod 4491 4492 4493 Bias MinLod 4495 4494
+            4497:    208(ptr) AccessChain 4391(texel) 207
+            4498:    6(float) Load 4497
+            4499:    6(float) FAdd 4498 4496
+            4500:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4500 4499
+            4501:         269 Load 271(s1DArray)
+            4502:   53(fvec2) Load 148(c2)
+            4503:   52(float) Load 4257(lodClamp)
+            4504:    7(fvec4) ImageSampleImplicitLod 4501 4502 MinLod 4503
+            4505:    7(fvec4) Load 4391(texel)
+            4506:    7(fvec4) FAdd 4505 4504
+                              Store 4391(texel) 4506
+            4507:         269 Load 271(s1DArray)
+            4508:  154(fvec2) Load 156(f16c2)
+            4509:    6(float) Load 4264(f16lodClamp)
+            4510:    6(float) Load 137(f16bias)
+            4511:    7(fvec4) ImageSampleImplicitLod 4507 4508 Bias MinLod 4510 4509
+            4512:    7(fvec4) Load 4391(texel)
+            4513:    7(fvec4) FAdd 4512 4511
+                              Store 4391(texel) 4513
+            4514:         284 Load 286(s2DArray)
+            4515:  167(fvec3) Load 169(c3)
+            4516:   52(float) Load 4257(lodClamp)
+            4517:    7(fvec4) ImageSampleImplicitLod 4514 4515 MinLod 4516
+            4518:    7(fvec4) Load 4391(texel)
+            4519:    7(fvec4) FAdd 4518 4517
+                              Store 4391(texel) 4519
+            4520:         284 Load 286(s2DArray)
+            4521:  175(fvec3) Load 177(f16c3)
+            4522:    6(float) Load 4264(f16lodClamp)
+            4523:    6(float) Load 137(f16bias)
+            4524:    7(fvec4) ImageSampleImplicitLod 4520 4521 Bias MinLod 4523 4522
+            4525:    7(fvec4) Load 4391(texel)
+            4526:    7(fvec4) FAdd 4525 4524
+                              Store 4391(texel) 4526
+            4527:         299 Load 301(sCubeArray)
+            4528:  249(fvec4) Load 251(c4)
+            4529:   52(float) Load 4257(lodClamp)
+            4530:    7(fvec4) ImageSampleImplicitLod 4527 4528 MinLod 4529
+            4531:    7(fvec4) Load 4391(texel)
+            4532:    7(fvec4) FAdd 4531 4530
+                              Store 4391(texel) 4532
+            4533:         299 Load 301(sCubeArray)
+            4534:    7(fvec4) Load 309(f16c4)
+            4535:    6(float) Load 4264(f16lodClamp)
+            4536:    6(float) Load 137(f16bias)
+            4537:    7(fvec4) ImageSampleImplicitLod 4533 4534 Bias MinLod 4536 4535
+            4538:    7(fvec4) Load 4391(texel)
+            4539:    7(fvec4) FAdd 4538 4537
+                              Store 4391(texel) 4539
+            4540:         316 Load 318(s1DArrayShadow)
+            4541:  167(fvec3) Load 169(c3)
+            4542:   52(float) Load 4257(lodClamp)
+            4543:   52(float) CompositeExtract 4541 2
+            4544:    6(float) ImageSampleDrefImplicitLod 4540 4541 4543 MinLod 4542
+            4545:    208(ptr) AccessChain 4391(texel) 207
+            4546:    6(float) Load 4545
+            4547:    6(float) FAdd 4546 4544
+            4548:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4548 4547
+            4549:         316 Load 318(s1DArrayShadow)
+            4550:  154(fvec2) Load 156(f16c2)
+            4551:   52(float) Load 215(compare)
+            4552:    6(float) Load 4264(f16lodClamp)
+            4553:    6(float) Load 137(f16bias)
+            4554:    6(float) ImageSampleDrefImplicitLod 4549 4550 4551 Bias MinLod 4553 4552
+            4555:    208(ptr) AccessChain 4391(texel) 207
+            4556:    6(float) Load 4555
+            4557:    6(float) FAdd 4556 4554
+            4558:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4558 4557
+            4559:         337 Load 339(s2DArrayShadow)
+            4560:  249(fvec4) Load 251(c4)
+            4561:   52(float) Load 4257(lodClamp)
+            4562:   52(float) CompositeExtract 4560 3
+            4563:    6(float) ImageSampleDrefImplicitLod 4559 4560 4562 MinLod 4561
+            4564:    208(ptr) AccessChain 4391(texel) 207
+            4565:    6(float) Load 4564
+            4566:    6(float) FAdd 4565 4563
+            4567:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4567 4566
+            4568:         337 Load 339(s2DArrayShadow)
+            4569:  175(fvec3) Load 177(f16c3)
+            4570:   52(float) Load 215(compare)
+            4571:    6(float) Load 4264(f16lodClamp)
+            4572:    6(float) ImageSampleDrefImplicitLod 4568 4569 4570 MinLod 4571
+            4573:    208(ptr) AccessChain 4391(texel) 207
+            4574:    6(float) Load 4573
+            4575:    6(float) FAdd 4574 4572
+            4576:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4576 4575
+            4577:         391 Load 393(sCubeArrayShadow)
+            4578:  249(fvec4) Load 251(c4)
+            4579:   52(float) Load 215(compare)
+            4580:   52(float) Load 4257(lodClamp)
+            4581:    6(float) ImageSampleDrefImplicitLod 4577 4578 4579 MinLod 4580
+            4582:    208(ptr) AccessChain 4391(texel) 207
+            4583:    6(float) Load 4582
+            4584:    6(float) FAdd 4583 4581
+            4585:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4585 4584
+            4586:         391 Load 393(sCubeArrayShadow)
+            4587:    7(fvec4) Load 309(f16c4)
+            4588:   52(float) Load 215(compare)
+            4589:    6(float) Load 4264(f16lodClamp)
+            4590:    6(float) ImageSampleDrefImplicitLod 4586 4587 4588 MinLod 4589
+            4591:    208(ptr) AccessChain 4391(texel) 207
+            4592:    6(float) Load 4591
+            4593:    6(float) FAdd 4592 4590
+            4594:    208(ptr) AccessChain 4391(texel) 207
+                              Store 4594 4593
+            4595:    7(fvec4) Load 4391(texel)
+                              ReturnValue 4595
+                              FunctionEnd
+103(testSparseTextureOffsetClamp():    7(fvec4) Function None 8
+             104:             Label
+     4598(texel):     64(ptr) Variable Function
+                              Store 4598(texel) 121
+            4599:         143 Load 145(s2D)
+            4600:   53(fvec2) Load 148(c2)
+            4601:   52(float) Load 4257(lodClamp)
+            4602:3102(ResType) ImageSparseSampleImplicitLod 4599 4600 ConstOffset MinLod 722 4601
+            4603:    7(fvec4) CompositeExtract 4602 1
+                              Store 4598(texel) 4603
+            4604:     47(int) CompositeExtract 4602 0
+            4605:         143 Load 145(s2D)
+            4606:  154(fvec2) Load 156(f16c2)
+            4607:    6(float) Load 4264(f16lodClamp)
+            4608:    6(float) Load 137(f16bias)
+            4609:3102(ResType) ImageSparseSampleImplicitLod 4605 4606 Bias ConstOffset MinLod 4608 722 4607
+            4610:    7(fvec4) CompositeExtract 4609 1
+                              Store 4598(texel) 4610
+            4611:     47(int) CompositeExtract 4609 0
+            4612:         163 Load 165(s3D)
+            4613:  167(fvec3) Load 169(c3)
+            4614:   52(float) Load 4257(lodClamp)
+            4615:3102(ResType) ImageSparseSampleImplicitLod 4612 4613 ConstOffset MinLod 735 4614
+            4616:    7(fvec4) CompositeExtract 4615 1
+                              Store 4598(texel) 4616
+            4617:     47(int) CompositeExtract 4615 0
+            4618:         163 Load 165(s3D)
+            4619:  175(fvec3) Load 177(f16c3)
+            4620:    6(float) Load 4264(f16lodClamp)
+            4621:    6(float) Load 137(f16bias)
+            4622:3102(ResType) ImageSparseSampleImplicitLod 4618 4619 Bias ConstOffset MinLod 4621 735 4620
+            4623:    7(fvec4) CompositeExtract 4622 1
+                              Store 4598(texel) 4623
+            4624:     47(int) CompositeExtract 4622 0
+            4625:         224 Load 226(s2DShadow)
+            4626:  167(fvec3) Load 169(c3)
+            4627:   52(float) Load 4257(lodClamp)
+            4628:    208(ptr) AccessChain 4598(texel) 207
+            4629:   52(float) CompositeExtract 4626 2
+            4630:3138(ResType) ImageSparseSampleDrefImplicitLod 4625 4626 4629 ConstOffset MinLod 722 4627
+            4631:    6(float) CompositeExtract 4630 1
+                              Store 4628 4631
+            4632:     47(int) CompositeExtract 4630 0
+            4633:         224 Load 226(s2DShadow)
+            4634:  154(fvec2) Load 156(f16c2)
+            4635:   52(float) Load 215(compare)
+            4636:    6(float) Load 4264(f16lodClamp)
+            4637:    208(ptr) AccessChain 4598(texel) 207
+            4638:    6(float) Load 137(f16bias)
+            4639:3138(ResType) ImageSparseSampleDrefImplicitLod 4633 4634 4635 Bias ConstOffset MinLod 4638 722 4636
+            4640:    6(float) CompositeExtract 4639 1
+                              Store 4637 4640
+            4641:     47(int) CompositeExtract 4639 0
+            4642:         284 Load 286(s2DArray)
+            4643:  167(fvec3) Load 169(c3)
+            4644:   52(float) Load 4257(lodClamp)
+            4645:3102(ResType) ImageSparseSampleImplicitLod 4642 4643 ConstOffset MinLod 722 4644
+            4646:    7(fvec4) CompositeExtract 4645 1
+                              Store 4598(texel) 4646
+            4647:     47(int) CompositeExtract 4645 0
+            4648:         284 Load 286(s2DArray)
+            4649:  175(fvec3) Load 177(f16c3)
+            4650:    6(float) Load 4264(f16lodClamp)
+            4651:    6(float) Load 137(f16bias)
+            4652:3102(ResType) ImageSparseSampleImplicitLod 4648 4649 Bias ConstOffset MinLod 4651 722 4650
+            4653:    7(fvec4) CompositeExtract 4652 1
+                              Store 4598(texel) 4653
+            4654:     47(int) CompositeExtract 4652 0
+            4655:         337 Load 339(s2DArrayShadow)
+            4656:  249(fvec4) Load 251(c4)
+            4657:   52(float) Load 4257(lodClamp)
+            4658:    208(ptr) AccessChain 4598(texel) 207
+            4659:   52(float) CompositeExtract 4656 3
+            4660:3138(ResType) ImageSparseSampleDrefImplicitLod 4655 4656 4659 ConstOffset MinLod 722 4657
+            4661:    6(float) CompositeExtract 4660 1
+                              Store 4658 4661
+            4662:     47(int) CompositeExtract 4660 0
+            4663:         337 Load 339(s2DArrayShadow)
+            4664:  175(fvec3) Load 177(f16c3)
+            4665:   52(float) Load 215(compare)
+            4666:    6(float) Load 4264(f16lodClamp)
+            4667:    208(ptr) AccessChain 4598(texel) 207
+            4668:3138(ResType) ImageSparseSampleDrefImplicitLod 4663 4664 4665 ConstOffset MinLod 722 4666
+            4669:    6(float) CompositeExtract 4668 1
+                              Store 4667 4669
+            4670:     47(int) CompositeExtract 4668 0
+            4671:    7(fvec4) Load 4598(texel)
+                              ReturnValue 4671
+                              FunctionEnd
+105(testTextureOffsetClamp():    7(fvec4) Function None 8
+             106:             Label
+     4674(texel):     64(ptr) Variable Function
+                              Store 4674(texel) 121
+            4675:         123 Load 125(s1D)
+            4676:   52(float) Load 128(c1)
+            4677:   52(float) Load 4257(lodClamp)
+            4678:    7(fvec4) ImageSampleImplicitLod 4675 4676 ConstOffset MinLod 709 4677
+            4679:    7(fvec4) Load 4674(texel)
+            4680:    7(fvec4) FAdd 4679 4678
+                              Store 4674(texel) 4680
+            4681:         123 Load 125(s1D)
+            4682:    6(float) Load 135(f16c1)
+            4683:    6(float) Load 4264(f16lodClamp)
+            4684:    6(float) Load 137(f16bias)
+            4685:    7(fvec4) ImageSampleImplicitLod 4681 4682 Bias ConstOffset MinLod 4684 709 4683
+            4686:    7(fvec4) Load 4674(texel)
+            4687:    7(fvec4) FAdd 4686 4685
+                              Store 4674(texel) 4687
+            4688:         143 Load 145(s2D)
+            4689:   53(fvec2) Load 148(c2)
+            4690:   52(float) Load 4257(lodClamp)
+            4691:    7(fvec4) ImageSampleImplicitLod 4688 4689 ConstOffset MinLod 722 4690
+            4692:    7(fvec4) Load 4674(texel)
+            4693:    7(fvec4) FAdd 4692 4691
+                              Store 4674(texel) 4693
+            4694:         143 Load 145(s2D)
+            4695:  154(fvec2) Load 156(f16c2)
+            4696:    6(float) Load 4264(f16lodClamp)
+            4697:    6(float) Load 137(f16bias)
+            4698:    7(fvec4) ImageSampleImplicitLod 4694 4695 Bias ConstOffset MinLod 4697 722 4696
+            4699:    7(fvec4) Load 4674(texel)
+            4700:    7(fvec4) FAdd 4699 4698
+                              Store 4674(texel) 4700
+            4701:         163 Load 165(s3D)
+            4702:  167(fvec3) Load 169(c3)
+            4703:   52(float) Load 4257(lodClamp)
+            4704:    7(fvec4) ImageSampleImplicitLod 4701 4702 ConstOffset MinLod 735 4703
+            4705:    7(fvec4) Load 4674(texel)
+            4706:    7(fvec4) FAdd 4705 4704
+                              Store 4674(texel) 4706
+            4707:         163 Load 165(s3D)
+            4708:  175(fvec3) Load 177(f16c3)
+            4709:    6(float) Load 4264(f16lodClamp)
+            4710:    6(float) Load 137(f16bias)
+            4711:    7(fvec4) ImageSampleImplicitLod 4707 4708 Bias ConstOffset MinLod 4710 735 4709
+            4712:    7(fvec4) Load 4674(texel)
+            4713:    7(fvec4) FAdd 4712 4711
+                              Store 4674(texel) 4713
+            4714:         199 Load 201(s1DShadow)
+            4715:  167(fvec3) Load 169(c3)
+            4716:   52(float) Load 4257(lodClamp)
+            4717:   52(float) CompositeExtract 4715 2
+            4718:    6(float) ImageSampleDrefImplicitLod 4714 4715 4717 ConstOffset MinLod 709 4716
+            4719:    208(ptr) AccessChain 4674(texel) 207
+            4720:    6(float) Load 4719
+            4721:    6(float) FAdd 4720 4718
+            4722:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4722 4721
+            4723:         199 Load 201(s1DShadow)
+            4724:  154(fvec2) Load 156(f16c2)
+            4725:   52(float) Load 215(compare)
+            4726:    6(float) Load 4264(f16lodClamp)
+            4727:    6(float) Load 137(f16bias)
+            4728:    6(float) ImageSampleDrefImplicitLod 4723 4724 4725 Bias ConstOffset MinLod 4727 709 4726
+            4729:    208(ptr) AccessChain 4674(texel) 207
+            4730:    6(float) Load 4729
+            4731:    6(float) FAdd 4730 4728
+            4732:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4732 4731
+            4733:         224 Load 226(s2DShadow)
+            4734:  167(fvec3) Load 169(c3)
+            4735:   52(float) Load 4257(lodClamp)
+            4736:   52(float) CompositeExtract 4734 2
+            4737:    6(float) ImageSampleDrefImplicitLod 4733 4734 4736 ConstOffset MinLod 722 4735
+            4738:    208(ptr) AccessChain 4674(texel) 207
+            4739:    6(float) Load 4738
+            4740:    6(float) FAdd 4739 4737
+            4741:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4741 4740
+            4742:         224 Load 226(s2DShadow)
+            4743:  154(fvec2) Load 156(f16c2)
+            4744:   52(float) Load 215(compare)
+            4745:    6(float) Load 4264(f16lodClamp)
+            4746:    6(float) Load 137(f16bias)
+            4747:    6(float) ImageSampleDrefImplicitLod 4742 4743 4744 Bias ConstOffset MinLod 4746 722 4745
+            4748:    208(ptr) AccessChain 4674(texel) 207
+            4749:    6(float) Load 4748
+            4750:    6(float) FAdd 4749 4747
+            4751:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4751 4750
+            4752:         269 Load 271(s1DArray)
+            4753:   53(fvec2) Load 148(c2)
+            4754:   52(float) Load 4257(lodClamp)
+            4755:    7(fvec4) ImageSampleImplicitLod 4752 4753 ConstOffset MinLod 709 4754
+            4756:    7(fvec4) Load 4674(texel)
+            4757:    7(fvec4) FAdd 4756 4755
+                              Store 4674(texel) 4757
+            4758:         269 Load 271(s1DArray)
+            4759:  154(fvec2) Load 156(f16c2)
+            4760:    6(float) Load 4264(f16lodClamp)
+            4761:    6(float) Load 137(f16bias)
+            4762:    7(fvec4) ImageSampleImplicitLod 4758 4759 Bias ConstOffset MinLod 4761 709 4760
+            4763:    7(fvec4) Load 4674(texel)
+            4764:    7(fvec4) FAdd 4763 4762
+                              Store 4674(texel) 4764
+            4765:         284 Load 286(s2DArray)
+            4766:  167(fvec3) Load 169(c3)
+            4767:   52(float) Load 4257(lodClamp)
+            4768:    7(fvec4) ImageSampleImplicitLod 4765 4766 ConstOffset MinLod 722 4767
+            4769:    7(fvec4) Load 4674(texel)
+            4770:    7(fvec4) FAdd 4769 4768
+                              Store 4674(texel) 4770
+            4771:         284 Load 286(s2DArray)
+            4772:  175(fvec3) Load 177(f16c3)
+            4773:    6(float) Load 4264(f16lodClamp)
+            4774:    6(float) Load 137(f16bias)
+            4775:    7(fvec4) ImageSampleImplicitLod 4771 4772 Bias ConstOffset MinLod 4774 722 4773
+            4776:    7(fvec4) Load 4674(texel)
+            4777:    7(fvec4) FAdd 4776 4775
+                              Store 4674(texel) 4777
+            4778:         316 Load 318(s1DArrayShadow)
+            4779:  167(fvec3) Load 169(c3)
+            4780:   52(float) Load 4257(lodClamp)
+            4781:   52(float) CompositeExtract 4779 2
+            4782:    6(float) ImageSampleDrefImplicitLod 4778 4779 4781 ConstOffset MinLod 709 4780
+            4783:    208(ptr) AccessChain 4674(texel) 207
+            4784:    6(float) Load 4783
+            4785:    6(float) FAdd 4784 4782
+            4786:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4786 4785
+            4787:         316 Load 318(s1DArrayShadow)
+            4788:  154(fvec2) Load 156(f16c2)
+            4789:   52(float) Load 215(compare)
+            4790:    6(float) Load 4264(f16lodClamp)
+            4791:    6(float) Load 137(f16bias)
+            4792:    6(float) ImageSampleDrefImplicitLod 4787 4788 4789 Bias ConstOffset MinLod 4791 709 4790
+            4793:    208(ptr) AccessChain 4674(texel) 207
+            4794:    6(float) Load 4793
+            4795:    6(float) FAdd 4794 4792
+            4796:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4796 4795
+            4797:         337 Load 339(s2DArrayShadow)
+            4798:  249(fvec4) Load 251(c4)
+            4799:   52(float) Load 4257(lodClamp)
+            4800:   52(float) CompositeExtract 4798 3
+            4801:    6(float) ImageSampleDrefImplicitLod 4797 4798 4800 ConstOffset MinLod 722 4799
+            4802:    208(ptr) AccessChain 4674(texel) 207
+            4803:    6(float) Load 4802
+            4804:    6(float) FAdd 4803 4801
+            4805:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4805 4804
+            4806:         337 Load 339(s2DArrayShadow)
+            4807:  175(fvec3) Load 177(f16c3)
+            4808:   52(float) Load 215(compare)
+            4809:    6(float) Load 4264(f16lodClamp)
+            4810:    6(float) ImageSampleDrefImplicitLod 4806 4807 4808 ConstOffset MinLod 722 4809
+            4811:    208(ptr) AccessChain 4674(texel) 207
+            4812:    6(float) Load 4811
+            4813:    6(float) FAdd 4812 4810
+            4814:    208(ptr) AccessChain 4674(texel) 207
+                              Store 4814 4813
+            4815:    7(fvec4) Load 4674(texel)
+                              ReturnValue 4815
+                              FunctionEnd
+107(testSparseTextureGradClamp():    7(fvec4) Function None 8
+             108:             Label
+     4818(texel):     64(ptr) Variable Function
+                              Store 4818(texel) 121
+            4819:         143 Load 145(s2D)
+            4820:   53(fvec2) Load 148(c2)
+            4821:   53(fvec2) Load 1409(dPdxy2)
+            4822:   53(fvec2) Load 1409(dPdxy2)
+            4823:   52(float) Load 4257(lodClamp)
+            4824:3102(ResType) ImageSparseSampleExplicitLod 4819 4820 Grad MinLod 4821 4822 4823
+            4825:    7(fvec4) CompositeExtract 4824 1
+                              Store 4818(texel) 4825
+            4826:     47(int) CompositeExtract 4824 0
+            4827:         143 Load 145(s2D)
+            4828:  154(fvec2) Load 156(f16c2)
+            4829:  154(fvec2) Load 1417(f16dPdxy2)
+            4830:  154(fvec2) Load 1417(f16dPdxy2)
+            4831:    6(float) Load 4264(f16lodClamp)
+            4832:3102(ResType) ImageSparseSampleExplicitLod 4827 4828 Grad MinLod 4829 4830 4831
+            4833:    7(fvec4) CompositeExtract 4832 1
+                              Store 4818(texel) 4833
+            4834:     47(int) CompositeExtract 4832 0
+            4835:         163 Load 165(s3D)
+            4836:  167(fvec3) Load 169(c3)
+            4837:  167(fvec3) Load 1425(dPdxy3)
+            4838:  167(fvec3) Load 1425(dPdxy3)
+            4839:   52(float) Load 4257(lodClamp)
+            4840:3102(ResType) ImageSparseSampleExplicitLod 4835 4836 Grad MinLod 4837 4838 4839
+            4841:    7(fvec4) CompositeExtract 4840 1
+                              Store 4818(texel) 4841
+            4842:     47(int) CompositeExtract 4840 0
+            4843:         163 Load 165(s3D)
+            4844:  175(fvec3) Load 177(f16c3)
+            4845:  175(fvec3) Load 1433(f16dPdxy3)
+            4846:  175(fvec3) Load 1433(f16dPdxy3)
+            4847:    6(float) Load 4264(f16lodClamp)
+            4848:3102(ResType) ImageSparseSampleExplicitLod 4843 4844 Grad MinLod 4845 4846 4847
+            4849:    7(fvec4) CompositeExtract 4848 1
+                              Store 4818(texel) 4849
+            4850:     47(int) CompositeExtract 4848 0
+            4851:         184 Load 186(sCube)
+            4852:  167(fvec3) Load 169(c3)
+            4853:  167(fvec3) Load 1425(dPdxy3)
+            4854:  167(fvec3) Load 1425(dPdxy3)
+            4855:   52(float) Load 4257(lodClamp)
+            4856:3102(ResType) ImageSparseSampleExplicitLod 4851 4852 Grad MinLod 4853 4854 4855
+            4857:    7(fvec4) CompositeExtract 4856 1
+                              Store 4818(texel) 4857
+            4858:     47(int) CompositeExtract 4856 0
+            4859:         184 Load 186(sCube)
+            4860:  175(fvec3) Load 177(f16c3)
+            4861:  175(fvec3) Load 1433(f16dPdxy3)
+            4862:  175(fvec3) Load 1433(f16dPdxy3)
+            4863:    6(float) Load 4264(f16lodClamp)
+            4864:3102(ResType) ImageSparseSampleExplicitLod 4859 4860 Grad MinLod 4861 4862 4863
+            4865:    7(fvec4) CompositeExtract 4864 1
+                              Store 4818(texel) 4865
+            4866:     47(int) CompositeExtract 4864 0
+            4867:         224 Load 226(s2DShadow)
+            4868:  167(fvec3) Load 169(c3)
+            4869:   53(fvec2) Load 1409(dPdxy2)
+            4870:   53(fvec2) Load 1409(dPdxy2)
+            4871:   52(float) Load 4257(lodClamp)
+            4872:    208(ptr) AccessChain 4818(texel) 207
+            4873:   52(float) CompositeExtract 4868 2
+            4874:3138(ResType) ImageSparseSampleDrefExplicitLod 4867 4868 4873 Grad MinLod 4869 4870 4871
+            4875:    6(float) CompositeExtract 4874 1
+                              Store 4872 4875
+            4876:     47(int) CompositeExtract 4874 0
+            4877:         224 Load 226(s2DShadow)
+            4878:  154(fvec2) Load 156(f16c2)
+            4879:   52(float) Load 215(compare)
+            4880:  154(fvec2) Load 1417(f16dPdxy2)
+            4881:  154(fvec2) Load 1417(f16dPdxy2)
+            4882:    6(float) Load 4264(f16lodClamp)
+            4883:    208(ptr) AccessChain 4818(texel) 207
+            4884:3138(ResType) ImageSparseSampleDrefExplicitLod 4877 4878 4879 Grad MinLod 4880 4881 4882
+            4885:    6(float) CompositeExtract 4884 1
+                              Store 4883 4885
+            4886:     47(int) CompositeExtract 4884 0
+            4887:         245 Load 247(sCubeShadow)
+            4888:  249(fvec4) Load 251(c4)
+            4889:  167(fvec3) Load 1425(dPdxy3)
+            4890:  167(fvec3) Load 1425(dPdxy3)
+            4891:   52(float) Load 4257(lodClamp)
+            4892:    208(ptr) AccessChain 4818(texel) 207
+            4893:   52(float) CompositeExtract 4888 3
+            4894:3138(ResType) ImageSparseSampleDrefExplicitLod 4887 4888 4893 Grad MinLod 4889 4890 4891
+            4895:    6(float) CompositeExtract 4894 1
+                              Store 4892 4895
+            4896:     47(int) CompositeExtract 4894 0
+            4897:         245 Load 247(sCubeShadow)
+            4898:  175(fvec3) Load 177(f16c3)
+            4899:   52(float) Load 215(compare)
+            4900:  175(fvec3) Load 1433(f16dPdxy3)
+            4901:  175(fvec3) Load 1433(f16dPdxy3)
+            4902:    6(float) Load 4264(f16lodClamp)
+            4903:    208(ptr) AccessChain 4818(texel) 207
+            4904:3138(ResType) ImageSparseSampleDrefExplicitLod 4897 4898 4899 Grad MinLod 4900 4901 4902
+            4905:    6(float) CompositeExtract 4904 1
+                              Store 4903 4905
+            4906:     47(int) CompositeExtract 4904 0
+            4907:         284 Load 286(s2DArray)
+            4908:  167(fvec3) Load 169(c3)
+            4909:   53(fvec2) Load 1409(dPdxy2)
+            4910:   53(fvec2) Load 1409(dPdxy2)
+            4911:   52(float) Load 4257(lodClamp)
+            4912:3102(ResType) ImageSparseSampleExplicitLod 4907 4908 Grad MinLod 4909 4910 4911
+            4913:    7(fvec4) CompositeExtract 4912 1
+                              Store 4818(texel) 4913
+            4914:     47(int) CompositeExtract 4912 0
+            4915:         284 Load 286(s2DArray)
+            4916:  175(fvec3) Load 177(f16c3)
+            4917:  154(fvec2) Load 1417(f16dPdxy2)
+            4918:  154(fvec2) Load 1417(f16dPdxy2)
+            4919:    6(float) Load 4264(f16lodClamp)
+            4920:3102(ResType) ImageSparseSampleExplicitLod 4915 4916 Grad MinLod 4917 4918 4919
+            4921:    7(fvec4) CompositeExtract 4920 1
+                              Store 4818(texel) 4921
+            4922:     47(int) CompositeExtract 4920 0
+            4923:         337 Load 339(s2DArrayShadow)
+            4924:  249(fvec4) Load 251(c4)
+            4925:   53(fvec2) Load 1409(dPdxy2)
+            4926:   53(fvec2) Load 1409(dPdxy2)
+            4927:   52(float) Load 4257(lodClamp)
+            4928:    208(ptr) AccessChain 4818(texel) 207
+            4929:   52(float) CompositeExtract 4924 3
+            4930:3138(ResType) ImageSparseSampleDrefExplicitLod 4923 4924 4929 Grad MinLod 4925 4926 4927
+            4931:    6(float) CompositeExtract 4930 1
+                              Store 4928 4931
+            4932:     47(int) CompositeExtract 4930 0
+            4933:         337 Load 339(s2DArrayShadow)
+            4934:  175(fvec3) Load 177(f16c3)
+            4935:   52(float) Load 215(compare)
+            4936:  154(fvec2) Load 1417(f16dPdxy2)
+            4937:  154(fvec2) Load 1417(f16dPdxy2)
+            4938:    6(float) Load 4264(f16lodClamp)
+            4939:    208(ptr) AccessChain 4818(texel) 207
+            4940:3138(ResType) ImageSparseSampleDrefExplicitLod 4933 4934 4935 Grad MinLod 4936 4937 4938
+            4941:    6(float) CompositeExtract 4940 1
+                              Store 4939 4941
+            4942:     47(int) CompositeExtract 4940 0
+            4943:         299 Load 301(sCubeArray)
+            4944:  249(fvec4) Load 251(c4)
+            4945:  167(fvec3) Load 1425(dPdxy3)
+            4946:  167(fvec3) Load 1425(dPdxy3)
+            4947:   52(float) Load 4257(lodClamp)
+            4948:3102(ResType) ImageSparseSampleExplicitLod 4943 4944 Grad MinLod 4945 4946 4947
+            4949:    7(fvec4) CompositeExtract 4948 1
+                              Store 4818(texel) 4949
+            4950:     47(int) CompositeExtract 4948 0
+            4951:         299 Load 301(sCubeArray)
+            4952:    7(fvec4) Load 309(f16c4)
+            4953:  175(fvec3) Load 1433(f16dPdxy3)
+            4954:  175(fvec3) Load 1433(f16dPdxy3)
+            4955:    6(float) Load 4264(f16lodClamp)
+            4956:3102(ResType) ImageSparseSampleExplicitLod 4951 4952 Grad MinLod 4953 4954 4955
+            4957:    7(fvec4) CompositeExtract 4956 1
+                              Store 4818(texel) 4957
+            4958:     47(int) CompositeExtract 4956 0
+            4959:    7(fvec4) Load 4818(texel)
+                              ReturnValue 4959
+                              FunctionEnd
+109(testTextureGradClamp():    7(fvec4) Function None 8
+             110:             Label
+     4962(texel):     64(ptr) Variable Function
+                              Store 4962(texel) 121
+            4963:         123 Load 125(s1D)
+            4964:   52(float) Load 128(c1)
+            4965:   52(float) Load 1393(dPdxy1)
+            4966:   52(float) Load 1393(dPdxy1)
+            4967:   52(float) Load 4257(lodClamp)
+            4968:    7(fvec4) ImageSampleExplicitLod 4963 4964 Grad MinLod 4965 4966 4967
+            4969:    7(fvec4) Load 4962(texel)
+            4970:    7(fvec4) FAdd 4969 4968
+                              Store 4962(texel) 4970
+            4971:         123 Load 125(s1D)
+            4972:    6(float) Load 135(f16c1)
+            4973:    6(float) Load 1401(f16dPdxy1)
+            4974:    6(float) Load 1401(f16dPdxy1)
+            4975:    6(float) Load 4264(f16lodClamp)
+            4976:    7(fvec4) ImageSampleExplicitLod 4971 4972 Grad MinLod 4973 4974 4975
+            4977:    7(fvec4) Load 4962(texel)
+            4978:    7(fvec4) FAdd 4977 4976
+                              Store 4962(texel) 4978
+            4979:         143 Load 145(s2D)
+            4980:   53(fvec2) Load 148(c2)
+            4981:   53(fvec2) Load 1409(dPdxy2)
+            4982:   53(fvec2) Load 1409(dPdxy2)
+            4983:   52(float) Load 4257(lodClamp)
+            4984:    7(fvec4) ImageSampleExplicitLod 4979 4980 Grad MinLod 4981 4982 4983
+            4985:    7(fvec4) Load 4962(texel)
+            4986:    7(fvec4) FAdd 4985 4984
+                              Store 4962(texel) 4986
+            4987:         143 Load 145(s2D)
+            4988:  154(fvec2) Load 156(f16c2)
+            4989:  154(fvec2) Load 1417(f16dPdxy2)
+            4990:  154(fvec2) Load 1417(f16dPdxy2)
+            4991:    6(float) Load 4264(f16lodClamp)
+            4992:    7(fvec4) ImageSampleExplicitLod 4987 4988 Grad MinLod 4989 4990 4991
+            4993:    7(fvec4) Load 4962(texel)
+            4994:    7(fvec4) FAdd 4993 4992
+                              Store 4962(texel) 4994
+            4995:         163 Load 165(s3D)
+            4996:  167(fvec3) Load 169(c3)
+            4997:  167(fvec3) Load 1425(dPdxy3)
+            4998:  167(fvec3) Load 1425(dPdxy3)
+            4999:   52(float) Load 4257(lodClamp)
+            5000:    7(fvec4) ImageSampleExplicitLod 4995 4996 Grad MinLod 4997 4998 4999
+            5001:    7(fvec4) Load 4962(texel)
+            5002:    7(fvec4) FAdd 5001 5000
+                              Store 4962(texel) 5002
+            5003:         163 Load 165(s3D)
+            5004:  175(fvec3) Load 177(f16c3)
+            5005:  175(fvec3) Load 1433(f16dPdxy3)
+            5006:  175(fvec3) Load 1433(f16dPdxy3)
+            5007:    6(float) Load 4264(f16lodClamp)
+            5008:    7(fvec4) ImageSampleExplicitLod 5003 5004 Grad MinLod 5005 5006 5007
+            5009:    7(fvec4) Load 4962(texel)
+            5010:    7(fvec4) FAdd 5009 5008
+                              Store 4962(texel) 5010
+            5011:         184 Load 186(sCube)
+            5012:  167(fvec3) Load 169(c3)
+            5013:  167(fvec3) Load 1425(dPdxy3)
+            5014:  167(fvec3) Load 1425(dPdxy3)
+            5015:   52(float) Load 4257(lodClamp)
+            5016:    7(fvec4) ImageSampleExplicitLod 5011 5012 Grad MinLod 5013 5014 5015
+            5017:    7(fvec4) Load 4962(texel)
+            5018:    7(fvec4) FAdd 5017 5016
+                              Store 4962(texel) 5018
+            5019:         184 Load 186(sCube)
+            5020:  175(fvec3) Load 177(f16c3)
+            5021:  175(fvec3) Load 1433(f16dPdxy3)
+            5022:  175(fvec3) Load 1433(f16dPdxy3)
+            5023:    6(float) Load 4264(f16lodClamp)
+            5024:    7(fvec4) ImageSampleExplicitLod 5019 5020 Grad MinLod 5021 5022 5023
+            5025:    7(fvec4) Load 4962(texel)
+            5026:    7(fvec4) FAdd 5025 5024
+                              Store 4962(texel) 5026
+            5027:         199 Load 201(s1DShadow)
+            5028:  167(fvec3) Load 169(c3)
+            5029:   52(float) Load 1393(dPdxy1)
+            5030:   52(float) Load 1393(dPdxy1)
+            5031:   52(float) Load 4257(lodClamp)
+            5032:   52(float) CompositeExtract 5028 2
+            5033:    6(float) ImageSampleDrefExplicitLod 5027 5028 5032 Grad MinLod 5029 5030 5031
+            5034:    208(ptr) AccessChain 4962(texel) 207
+            5035:    6(float) Load 5034
+            5036:    6(float) FAdd 5035 5033
+            5037:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5037 5036
+            5038:         199 Load 201(s1DShadow)
+            5039:  154(fvec2) Load 156(f16c2)
+            5040:   52(float) Load 215(compare)
+            5041:    6(float) Load 1401(f16dPdxy1)
+            5042:    6(float) Load 1401(f16dPdxy1)
+            5043:    6(float) Load 4264(f16lodClamp)
+            5044:    6(float) ImageSampleDrefExplicitLod 5038 5039 5040 Grad MinLod 5041 5042 5043
+            5045:    208(ptr) AccessChain 4962(texel) 207
+            5046:    6(float) Load 5045
+            5047:    6(float) FAdd 5046 5044
+            5048:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5048 5047
+            5049:         224 Load 226(s2DShadow)
+            5050:  167(fvec3) Load 169(c3)
+            5051:   53(fvec2) Load 1409(dPdxy2)
+            5052:   53(fvec2) Load 1409(dPdxy2)
+            5053:   52(float) Load 4257(lodClamp)
+            5054:   52(float) CompositeExtract 5050 2
+            5055:    6(float) ImageSampleDrefExplicitLod 5049 5050 5054 Grad MinLod 5051 5052 5053
+            5056:    208(ptr) AccessChain 4962(texel) 207
+            5057:    6(float) Load 5056
+            5058:    6(float) FAdd 5057 5055
+            5059:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5059 5058
+            5060:         224 Load 226(s2DShadow)
+            5061:  154(fvec2) Load 156(f16c2)
+            5062:   52(float) Load 215(compare)
+            5063:  154(fvec2) Load 1417(f16dPdxy2)
+            5064:  154(fvec2) Load 1417(f16dPdxy2)
+            5065:    6(float) Load 4264(f16lodClamp)
+            5066:    6(float) ImageSampleDrefExplicitLod 5060 5061 5062 Grad MinLod 5063 5064 5065
+            5067:    208(ptr) AccessChain 4962(texel) 207
+            5068:    6(float) Load 5067
+            5069:    6(float) FAdd 5068 5066
+            5070:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5070 5069
+            5071:         245 Load 247(sCubeShadow)
+            5072:  249(fvec4) Load 251(c4)
+            5073:  167(fvec3) Load 1425(dPdxy3)
+            5074:  167(fvec3) Load 1425(dPdxy3)
+            5075:   52(float) Load 4257(lodClamp)
+            5076:   52(float) CompositeExtract 5072 3
+            5077:    6(float) ImageSampleDrefExplicitLod 5071 5072 5076 Grad MinLod 5073 5074 5075
+            5078:    208(ptr) AccessChain 4962(texel) 207
+            5079:    6(float) Load 5078
+            5080:    6(float) FAdd 5079 5077
+            5081:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5081 5080
+            5082:         245 Load 247(sCubeShadow)
+            5083:  175(fvec3) Load 177(f16c3)
+            5084:   52(float) Load 215(compare)
+            5085:  175(fvec3) Load 1433(f16dPdxy3)
+            5086:  175(fvec3) Load 1433(f16dPdxy3)
+            5087:    6(float) Load 4264(f16lodClamp)
+            5088:    6(float) ImageSampleDrefExplicitLod 5082 5083 5084 Grad MinLod 5085 5086 5087
+            5089:    208(ptr) AccessChain 4962(texel) 207
+            5090:    6(float) Load 5089
+            5091:    6(float) FAdd 5090 5088
+            5092:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5092 5091
+            5093:         269 Load 271(s1DArray)
+            5094:   53(fvec2) Load 148(c2)
+            5095:   52(float) Load 1393(dPdxy1)
+            5096:   52(float) Load 1393(dPdxy1)
+            5097:   52(float) Load 4257(lodClamp)
+            5098:    7(fvec4) ImageSampleExplicitLod 5093 5094 Grad MinLod 5095 5096 5097
+            5099:    7(fvec4) Load 4962(texel)
+            5100:    7(fvec4) FAdd 5099 5098
+                              Store 4962(texel) 5100
+            5101:         269 Load 271(s1DArray)
+            5102:  154(fvec2) Load 156(f16c2)
+            5103:    6(float) Load 1401(f16dPdxy1)
+            5104:    6(float) Load 1401(f16dPdxy1)
+            5105:    6(float) Load 4264(f16lodClamp)
+            5106:    7(fvec4) ImageSampleExplicitLod 5101 5102 Grad MinLod 5103 5104 5105
+            5107:    7(fvec4) Load 4962(texel)
+            5108:    7(fvec4) FAdd 5107 5106
+                              Store 4962(texel) 5108
+            5109:         284 Load 286(s2DArray)
+            5110:  167(fvec3) Load 169(c3)
+            5111:   53(fvec2) Load 1409(dPdxy2)
+            5112:   53(fvec2) Load 1409(dPdxy2)
+            5113:   52(float) Load 4257(lodClamp)
+            5114:    7(fvec4) ImageSampleExplicitLod 5109 5110 Grad MinLod 5111 5112 5113
+            5115:    7(fvec4) Load 4962(texel)
+            5116:    7(fvec4) FAdd 5115 5114
+                              Store 4962(texel) 5116
+            5117:         284 Load 286(s2DArray)
+            5118:  175(fvec3) Load 177(f16c3)
+            5119:  154(fvec2) Load 1417(f16dPdxy2)
+            5120:  154(fvec2) Load 1417(f16dPdxy2)
+            5121:    6(float) Load 4264(f16lodClamp)
+            5122:    7(fvec4) ImageSampleExplicitLod 5117 5118 Grad MinLod 5119 5120 5121
+            5123:    7(fvec4) Load 4962(texel)
+            5124:    7(fvec4) FAdd 5123 5122
+                              Store 4962(texel) 5124
+            5125:         316 Load 318(s1DArrayShadow)
+            5126:  167(fvec3) Load 169(c3)
+            5127:   52(float) Load 1393(dPdxy1)
+            5128:   52(float) Load 1393(dPdxy1)
+            5129:   52(float) Load 4257(lodClamp)
+            5130:   52(float) CompositeExtract 5126 2
+            5131:    6(float) ImageSampleDrefExplicitLod 5125 5126 5130 Grad MinLod 5127 5128 5129
+            5132:    208(ptr) AccessChain 4962(texel) 207
+            5133:    6(float) Load 5132
+            5134:    6(float) FAdd 5133 5131
+            5135:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5135 5134
+            5136:         316 Load 318(s1DArrayShadow)
+            5137:  154(fvec2) Load 156(f16c2)
+            5138:   52(float) Load 215(compare)
+            5139:    6(float) Load 1401(f16dPdxy1)
+            5140:    6(float) Load 1401(f16dPdxy1)
+            5141:    6(float) Load 4264(f16lodClamp)
+            5142:    6(float) ImageSampleDrefExplicitLod 5136 5137 5138 Grad MinLod 5139 5140 5141
+            5143:    208(ptr) AccessChain 4962(texel) 207
+            5144:    6(float) Load 5143
+            5145:    6(float) FAdd 5144 5142
+            5146:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5146 5145
+            5147:         337 Load 339(s2DArrayShadow)
+            5148:  249(fvec4) Load 251(c4)
+            5149:   53(fvec2) Load 1409(dPdxy2)
+            5150:   53(fvec2) Load 1409(dPdxy2)
+            5151:   52(float) Load 4257(lodClamp)
+            5152:   52(float) CompositeExtract 5148 3
+            5153:    6(float) ImageSampleDrefExplicitLod 5147 5148 5152 Grad MinLod 5149 5150 5151
+            5154:    208(ptr) AccessChain 4962(texel) 207
+            5155:    6(float) Load 5154
+            5156:    6(float) FAdd 5155 5153
+            5157:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5157 5156
+            5158:         337 Load 339(s2DArrayShadow)
+            5159:  175(fvec3) Load 177(f16c3)
+            5160:   52(float) Load 215(compare)
+            5161:  154(fvec2) Load 1417(f16dPdxy2)
+            5162:  154(fvec2) Load 1417(f16dPdxy2)
+            5163:    6(float) Load 4264(f16lodClamp)
+            5164:    6(float) ImageSampleDrefExplicitLod 5158 5159 5160 Grad MinLod 5161 5162 5163
+            5165:    208(ptr) AccessChain 4962(texel) 207
+            5166:    6(float) Load 5165
+            5167:    6(float) FAdd 5166 5164
+            5168:    208(ptr) AccessChain 4962(texel) 207
+                              Store 5168 5167
+            5169:         299 Load 301(sCubeArray)
+            5170:  249(fvec4) Load 251(c4)
+            5171:  167(fvec3) Load 1425(dPdxy3)
+            5172:  167(fvec3) Load 1425(dPdxy3)
+            5173:   52(float) Load 4257(lodClamp)
+            5174:    7(fvec4) ImageSampleExplicitLod 5169 5170 Grad MinLod 5171 5172 5173
+            5175:    7(fvec4) Load 4962(texel)
+            5176:    7(fvec4) FAdd 5175 5174
+                              Store 4962(texel) 5176
+            5177:         299 Load 301(sCubeArray)
+            5178:    7(fvec4) Load 309(f16c4)
+            5179:  175(fvec3) Load 1433(f16dPdxy3)
+            5180:  175(fvec3) Load 1433(f16dPdxy3)
+            5181:    6(float) Load 4264(f16lodClamp)
+            5182:    7(fvec4) ImageSampleExplicitLod 5177 5178 Grad MinLod 5179 5180 5181
+            5183:    7(fvec4) Load 4962(texel)
+            5184:    7(fvec4) FAdd 5183 5182
+                              Store 4962(texel) 5184
+            5185:    7(fvec4) Load 4962(texel)
+                              ReturnValue 5185
+                              FunctionEnd
+111(testSparseTextureGradOffsetClamp():    7(fvec4) Function None 8
+             112:             Label
+     5188(texel):     64(ptr) Variable Function
+                              Store 5188(texel) 121
+            5189:         143 Load 145(s2D)
+            5190:   53(fvec2) Load 148(c2)
+            5191:   53(fvec2) Load 1409(dPdxy2)
+            5192:   53(fvec2) Load 1409(dPdxy2)
+            5193:   52(float) Load 4257(lodClamp)
+            5194:3102(ResType) ImageSparseSampleExplicitLod 5189 5190 Grad ConstOffset MinLod 5191 5192 722 5193
+            5195:    7(fvec4) CompositeExtract 5194 1
+                              Store 5188(texel) 5195
+            5196:     47(int) CompositeExtract 5194 0
+            5197:         143 Load 145(s2D)
+            5198:  154(fvec2) Load 156(f16c2)
+            5199:  154(fvec2) Load 1417(f16dPdxy2)
+            5200:  154(fvec2) Load 1417(f16dPdxy2)
+            5201:    6(float) Load 4264(f16lodClamp)
+            5202:3102(ResType) ImageSparseSampleExplicitLod 5197 5198 Grad ConstOffset MinLod 5199 5200 722 5201
+            5203:    7(fvec4) CompositeExtract 5202 1
+                              Store 5188(texel) 5203
+            5204:     47(int) CompositeExtract 5202 0
+            5205:         163 Load 165(s3D)
+            5206:  167(fvec3) Load 169(c3)
+            5207:  167(fvec3) Load 1425(dPdxy3)
+            5208:  167(fvec3) Load 1425(dPdxy3)
+            5209:   52(float) Load 4257(lodClamp)
+            5210:3102(ResType) ImageSparseSampleExplicitLod 5205 5206 Grad ConstOffset MinLod 5207 5208 735 5209
+            5211:    7(fvec4) CompositeExtract 5210 1
+                              Store 5188(texel) 5211
+            5212:     47(int) CompositeExtract 5210 0
+            5213:         163 Load 165(s3D)
+            5214:  175(fvec3) Load 177(f16c3)
+            5215:  175(fvec3) Load 1433(f16dPdxy3)
+            5216:  175(fvec3) Load 1433(f16dPdxy3)
+            5217:    6(float) Load 4264(f16lodClamp)
+            5218:3102(ResType) ImageSparseSampleExplicitLod 5213 5214 Grad ConstOffset MinLod 5215 5216 735 5217
+            5219:    7(fvec4) CompositeExtract 5218 1
+                              Store 5188(texel) 5219
+            5220:     47(int) CompositeExtract 5218 0
+            5221:         224 Load 226(s2DShadow)
+            5222:  167(fvec3) Load 169(c3)
+            5223:   53(fvec2) Load 1409(dPdxy2)
+            5224:   53(fvec2) Load 1409(dPdxy2)
+            5225:   52(float) Load 4257(lodClamp)
+            5226:    208(ptr) AccessChain 5188(texel) 207
+            5227:   52(float) CompositeExtract 5222 2
+            5228:3138(ResType) ImageSparseSampleDrefExplicitLod 5221 5222 5227 Grad ConstOffset MinLod 5223 5224 722 5225
+            5229:    6(float) CompositeExtract 5228 1
+                              Store 5226 5229
+            5230:     47(int) CompositeExtract 5228 0
+            5231:         224 Load 226(s2DShadow)
+            5232:  154(fvec2) Load 156(f16c2)
+            5233:   52(float) Load 215(compare)
+            5234:  154(fvec2) Load 1417(f16dPdxy2)
+            5235:  154(fvec2) Load 1417(f16dPdxy2)
+            5236:    6(float) Load 4264(f16lodClamp)
+            5237:    208(ptr) AccessChain 5188(texel) 207
+            5238:3138(ResType) ImageSparseSampleDrefExplicitLod 5231 5232 5233 Grad ConstOffset MinLod 5234 5235 722 5236
+            5239:    6(float) CompositeExtract 5238 1
+                              Store 5237 5239
+            5240:     47(int) CompositeExtract 5238 0
+            5241:         284 Load 286(s2DArray)
+            5242:  167(fvec3) Load 169(c3)
+            5243:   53(fvec2) Load 1409(dPdxy2)
+            5244:   53(fvec2) Load 1409(dPdxy2)
+            5245:   52(float) Load 4257(lodClamp)
+            5246:3102(ResType) ImageSparseSampleExplicitLod 5241 5242 Grad ConstOffset MinLod 5243 5244 722 5245
+            5247:    7(fvec4) CompositeExtract 5246 1
+                              Store 5188(texel) 5247
+            5248:     47(int) CompositeExtract 5246 0
+            5249:         284 Load 286(s2DArray)
+            5250:  175(fvec3) Load 177(f16c3)
+            5251:  154(fvec2) Load 1417(f16dPdxy2)
+            5252:  154(fvec2) Load 1417(f16dPdxy2)
+            5253:    6(float) Load 4264(f16lodClamp)
+            5254:3102(ResType) ImageSparseSampleExplicitLod 5249 5250 Grad ConstOffset MinLod 5251 5252 722 5253
+            5255:    7(fvec4) CompositeExtract 5254 1
+                              Store 5188(texel) 5255
+            5256:     47(int) CompositeExtract 5254 0
+            5257:         337 Load 339(s2DArrayShadow)
+            5258:  249(fvec4) Load 251(c4)
+            5259:   53(fvec2) Load 1409(dPdxy2)
+            5260:   53(fvec2) Load 1409(dPdxy2)
+            5261:   52(float) Load 4257(lodClamp)
+            5262:    208(ptr) AccessChain 5188(texel) 207
+            5263:   52(float) CompositeExtract 5258 3
+            5264:3138(ResType) ImageSparseSampleDrefExplicitLod 5257 5258 5263 Grad ConstOffset MinLod 5259 5260 722 5261
+            5265:    6(float) CompositeExtract 5264 1
+                              Store 5262 5265
+            5266:     47(int) CompositeExtract 5264 0
+            5267:         337 Load 339(s2DArrayShadow)
+            5268:  175(fvec3) Load 177(f16c3)
+            5269:   52(float) Load 215(compare)
+            5270:  154(fvec2) Load 1417(f16dPdxy2)
+            5271:  154(fvec2) Load 1417(f16dPdxy2)
+            5272:    6(float) Load 4264(f16lodClamp)
+            5273:    208(ptr) AccessChain 5188(texel) 207
+            5274:3138(ResType) ImageSparseSampleDrefExplicitLod 5267 5268 5269 Grad ConstOffset MinLod 5270 5271 722 5272
+            5275:    6(float) CompositeExtract 5274 1
+                              Store 5273 5275
+            5276:     47(int) CompositeExtract 5274 0
+            5277:    7(fvec4) Load 5188(texel)
+                              ReturnValue 5277
+                              FunctionEnd
+113(testTextureGradOffsetClamp():    7(fvec4) Function None 8
+             114:             Label
+     5280(texel):     64(ptr) Variable Function
+                              Store 5280(texel) 121
+            5281:         123 Load 125(s1D)
+            5282:   52(float) Load 128(c1)
+            5283:   52(float) Load 1393(dPdxy1)
+            5284:   52(float) Load 1393(dPdxy1)
+            5285:   52(float) Load 4257(lodClamp)
+            5286:    7(fvec4) ImageSampleExplicitLod 5281 5282 Grad ConstOffset MinLod 5283 5284 709 5285
+            5287:    7(fvec4) Load 5280(texel)
+            5288:    7(fvec4) FAdd 5287 5286
+                              Store 5280(texel) 5288
+            5289:         123 Load 125(s1D)
+            5290:    6(float) Load 135(f16c1)
+            5291:    6(float) Load 1401(f16dPdxy1)
+            5292:    6(float) Load 1401(f16dPdxy1)
+            5293:    6(float) Load 4264(f16lodClamp)
+            5294:    7(fvec4) ImageSampleExplicitLod 5289 5290 Grad ConstOffset MinLod 5291 5292 709 5293
+            5295:    7(fvec4) Load 5280(texel)
+            5296:    7(fvec4) FAdd 5295 5294
+                              Store 5280(texel) 5296
+            5297:         143 Load 145(s2D)
+            5298:   53(fvec2) Load 148(c2)
+            5299:   53(fvec2) Load 1409(dPdxy2)
+            5300:   53(fvec2) Load 1409(dPdxy2)
+            5301:   52(float) Load 4257(lodClamp)
+            5302:    7(fvec4) ImageSampleExplicitLod 5297 5298 Grad ConstOffset MinLod 5299 5300 722 5301
+            5303:    7(fvec4) Load 5280(texel)
+            5304:    7(fvec4) FAdd 5303 5302
+                              Store 5280(texel) 5304
+            5305:         143 Load 145(s2D)
+            5306:  154(fvec2) Load 156(f16c2)
+            5307:  154(fvec2) Load 1417(f16dPdxy2)
+            5308:  154(fvec2) Load 1417(f16dPdxy2)
+            5309:    6(float) Load 4264(f16lodClamp)
+            5310:    7(fvec4) ImageSampleExplicitLod 5305 5306 Grad ConstOffset MinLod 5307 5308 722 5309
+            5311:    7(fvec4) Load 5280(texel)
+            5312:    7(fvec4) FAdd 5311 5310
+                              Store 5280(texel) 5312
+            5313:         163 Load 165(s3D)
+            5314:  167(fvec3) Load 169(c3)
+            5315:  167(fvec3) Load 1425(dPdxy3)
+            5316:  167(fvec3) Load 1425(dPdxy3)
+            5317:   52(float) Load 4257(lodClamp)
+            5318:    7(fvec4) ImageSampleExplicitLod 5313 5314 Grad ConstOffset MinLod 5315 5316 735 5317
+            5319:    7(fvec4) Load 5280(texel)
+            5320:    7(fvec4) FAdd 5319 5318
+                              Store 5280(texel) 5320
+            5321:         163 Load 165(s3D)
+            5322:  175(fvec3) Load 177(f16c3)
+            5323:  175(fvec3) Load 1433(f16dPdxy3)
+            5324:  175(fvec3) Load 1433(f16dPdxy3)
+            5325:    6(float) Load 4264(f16lodClamp)
+            5326:    7(fvec4) ImageSampleExplicitLod 5321 5322 Grad ConstOffset MinLod 5323 5324 735 5325
+            5327:    7(fvec4) Load 5280(texel)
+            5328:    7(fvec4) FAdd 5327 5326
+                              Store 5280(texel) 5328
+            5329:         199 Load 201(s1DShadow)
+            5330:  167(fvec3) Load 169(c3)
+            5331:   52(float) Load 1393(dPdxy1)
+            5332:   52(float) Load 1393(dPdxy1)
+            5333:   52(float) Load 4257(lodClamp)
+            5334:   52(float) CompositeExtract 5330 2
+            5335:    6(float) ImageSampleDrefExplicitLod 5329 5330 5334 Grad ConstOffset MinLod 5331 5332 709 5333
+            5336:    208(ptr) AccessChain 5280(texel) 207
+            5337:    6(float) Load 5336
+            5338:    6(float) FAdd 5337 5335
+            5339:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5339 5338
+            5340:         199 Load 201(s1DShadow)
+            5341:  154(fvec2) Load 156(f16c2)
+            5342:   52(float) Load 215(compare)
+            5343:    6(float) Load 1401(f16dPdxy1)
+            5344:    6(float) Load 1401(f16dPdxy1)
+            5345:    6(float) Load 4264(f16lodClamp)
+            5346:    6(float) ImageSampleDrefExplicitLod 5340 5341 5342 Grad ConstOffset MinLod 5343 5344 709 5345
+            5347:    208(ptr) AccessChain 5280(texel) 207
+            5348:    6(float) Load 5347
+            5349:    6(float) FAdd 5348 5346
+            5350:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5350 5349
+            5351:         224 Load 226(s2DShadow)
+            5352:  167(fvec3) Load 169(c3)
+            5353:   53(fvec2) Load 1409(dPdxy2)
+            5354:   53(fvec2) Load 1409(dPdxy2)
+            5355:   52(float) Load 4257(lodClamp)
+            5356:   52(float) CompositeExtract 5352 2
+            5357:    6(float) ImageSampleDrefExplicitLod 5351 5352 5356 Grad ConstOffset MinLod 5353 5354 722 5355
+            5358:    208(ptr) AccessChain 5280(texel) 207
+            5359:    6(float) Load 5358
+            5360:    6(float) FAdd 5359 5357
+            5361:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5361 5360
+            5362:         224 Load 226(s2DShadow)
+            5363:  154(fvec2) Load 156(f16c2)
+            5364:   52(float) Load 215(compare)
+            5365:  154(fvec2) Load 1417(f16dPdxy2)
+            5366:  154(fvec2) Load 1417(f16dPdxy2)
+            5367:    6(float) Load 4264(f16lodClamp)
+            5368:    6(float) ImageSampleDrefExplicitLod 5362 5363 5364 Grad ConstOffset MinLod 5365 5366 722 5367
+            5369:    208(ptr) AccessChain 5280(texel) 207
+            5370:    6(float) Load 5369
+            5371:    6(float) FAdd 5370 5368
+            5372:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5372 5371
+            5373:         269 Load 271(s1DArray)
+            5374:   53(fvec2) Load 148(c2)
+            5375:   52(float) Load 1393(dPdxy1)
+            5376:   52(float) Load 1393(dPdxy1)
+            5377:   52(float) Load 4257(lodClamp)
+            5378:    7(fvec4) ImageSampleExplicitLod 5373 5374 Grad ConstOffset MinLod 5375 5376 709 5377
+            5379:    7(fvec4) Load 5280(texel)
+            5380:    7(fvec4) FAdd 5379 5378
+                              Store 5280(texel) 5380
+            5381:         269 Load 271(s1DArray)
+            5382:  154(fvec2) Load 156(f16c2)
+            5383:    6(float) Load 1401(f16dPdxy1)
+            5384:    6(float) Load 1401(f16dPdxy1)
+            5385:    6(float) Load 4264(f16lodClamp)
+            5386:    7(fvec4) ImageSampleExplicitLod 5381 5382 Grad ConstOffset MinLod 5383 5384 709 5385
+            5387:    7(fvec4) Load 5280(texel)
+            5388:    7(fvec4) FAdd 5387 5386
+                              Store 5280(texel) 5388
+            5389:         284 Load 286(s2DArray)
+            5390:  167(fvec3) Load 169(c3)
+            5391:   53(fvec2) Load 1409(dPdxy2)
+            5392:   53(fvec2) Load 1409(dPdxy2)
+            5393:   52(float) Load 4257(lodClamp)
+            5394:    7(fvec4) ImageSampleExplicitLod 5389 5390 Grad ConstOffset MinLod 5391 5392 722 5393
+            5395:    7(fvec4) Load 5280(texel)
+            5396:    7(fvec4) FAdd 5395 5394
+                              Store 5280(texel) 5396
+            5397:         284 Load 286(s2DArray)
+            5398:  175(fvec3) Load 177(f16c3)
+            5399:  154(fvec2) Load 1417(f16dPdxy2)
+            5400:  154(fvec2) Load 1417(f16dPdxy2)
+            5401:    6(float) Load 4264(f16lodClamp)
+            5402:    7(fvec4) ImageSampleExplicitLod 5397 5398 Grad ConstOffset MinLod 5399 5400 722 5401
+            5403:    7(fvec4) Load 5280(texel)
+            5404:    7(fvec4) FAdd 5403 5402
+                              Store 5280(texel) 5404
+            5405:         316 Load 318(s1DArrayShadow)
+            5406:  167(fvec3) Load 169(c3)
+            5407:   52(float) Load 1393(dPdxy1)
+            5408:   52(float) Load 1393(dPdxy1)
+            5409:   52(float) Load 4257(lodClamp)
+            5410:   52(float) CompositeExtract 5406 2
+            5411:    6(float) ImageSampleDrefExplicitLod 5405 5406 5410 Grad ConstOffset MinLod 5407 5408 709 5409
+            5412:    208(ptr) AccessChain 5280(texel) 207
+            5413:    6(float) Load 5412
+            5414:    6(float) FAdd 5413 5411
+            5415:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5415 5414
+            5416:         316 Load 318(s1DArrayShadow)
+            5417:  154(fvec2) Load 156(f16c2)
+            5418:   52(float) Load 215(compare)
+            5419:    6(float) Load 1401(f16dPdxy1)
+            5420:    6(float) Load 1401(f16dPdxy1)
+            5421:    6(float) Load 4264(f16lodClamp)
+            5422:    6(float) ImageSampleDrefExplicitLod 5416 5417 5418 Grad ConstOffset MinLod 5419 5420 709 5421
+            5423:    208(ptr) AccessChain 5280(texel) 207
+            5424:    6(float) Load 5423
+            5425:    6(float) FAdd 5424 5422
+            5426:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5426 5425
+            5427:         337 Load 339(s2DArrayShadow)
+            5428:  249(fvec4) Load 251(c4)
+            5429:   53(fvec2) Load 1409(dPdxy2)
+            5430:   53(fvec2) Load 1409(dPdxy2)
+            5431:   52(float) Load 4257(lodClamp)
+            5432:   52(float) CompositeExtract 5428 3
+            5433:    6(float) ImageSampleDrefExplicitLod 5427 5428 5432 Grad ConstOffset MinLod 5429 5430 722 5431
+            5434:    208(ptr) AccessChain 5280(texel) 207
+            5435:    6(float) Load 5434
+            5436:    6(float) FAdd 5435 5433
+            5437:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5437 5436
+            5438:         337 Load 339(s2DArrayShadow)
+            5439:  175(fvec3) Load 177(f16c3)
+            5440:   52(float) Load 215(compare)
+            5441:  154(fvec2) Load 1417(f16dPdxy2)
+            5442:  154(fvec2) Load 1417(f16dPdxy2)
+            5443:    6(float) Load 4264(f16lodClamp)
+            5444:    6(float) ImageSampleDrefExplicitLod 5438 5439 5440 Grad ConstOffset MinLod 5441 5442 722 5443
+            5445:    208(ptr) AccessChain 5280(texel) 207
+            5446:    6(float) Load 5445
+            5447:    6(float) FAdd 5446 5444
+            5448:    208(ptr) AccessChain 5280(texel) 207
+                              Store 5448 5447
+            5449:    7(fvec4) Load 5280(texel)
+                              ReturnValue 5449
+                              FunctionEnd
+115(testCombinedTextureSampler():    7(fvec4) Function None 8
+             116:             Label
+     5452(texel):     64(ptr) Variable Function
+                              Store 5452(texel) 121
+            5455:         122 Load 5454(t1D)
+            5459:        5456 Load 5458(s)
+            5460:         123 SampledImage 5455 5459
+            5461:   52(float) Load 128(c1)
+            5462:    7(fvec4) ImageSampleImplicitLod 5460 5461
+            5463:    7(fvec4) Load 5452(texel)
+            5464:    7(fvec4) FAdd 5463 5462
+                              Store 5452(texel) 5464
+            5465:         122 Load 5454(t1D)
+            5466:        5456 Load 5458(s)
+            5467:         123 SampledImage 5465 5466
+            5468:    6(float) Load 135(f16c1)
+            5469:    6(float) Load 137(f16bias)
+            5470:    7(fvec4) ImageSampleImplicitLod 5467 5468 Bias 5469
+            5471:    7(fvec4) Load 5452(texel)
+            5472:    7(fvec4) FAdd 5471 5470
+                              Store 5452(texel) 5472
+            5475:         142 Load 5474(t2D)
+            5476:        5456 Load 5458(s)
+            5477:         143 SampledImage 5475 5476
+            5478:   53(fvec2) Load 148(c2)
+            5479:    7(fvec4) ImageSampleImplicitLod 5477 5478
+            5480:    7(fvec4) Load 5452(texel)
+            5481:    7(fvec4) FAdd 5480 5479
+                              Store 5452(texel) 5481
+            5482:         142 Load 5474(t2D)
+            5483:        5456 Load 5458(s)
+            5484:         143 SampledImage 5482 5483
+            5485:  154(fvec2) Load 156(f16c2)
+            5486:    6(float) Load 137(f16bias)
+            5487:    7(fvec4) ImageSampleImplicitLod 5484 5485 Bias 5486
+            5488:    7(fvec4) Load 5452(texel)
+            5489:    7(fvec4) FAdd 5488 5487
+                              Store 5452(texel) 5489
+            5492:         162 Load 5491(t3D)
+            5493:        5456 Load 5458(s)
+            5494:         163 SampledImage 5492 5493
+            5495:  167(fvec3) Load 169(c3)
+            5496:    7(fvec4) ImageSampleImplicitLod 5494 5495
+            5497:    7(fvec4) Load 5452(texel)
+            5498:    7(fvec4) FAdd 5497 5496
+                              Store 5452(texel) 5498
+            5499:         162 Load 5491(t3D)
+            5500:        5456 Load 5458(s)
+            5501:         163 SampledImage 5499 5500
+            5502:  175(fvec3) Load 177(f16c3)
+            5503:    6(float) Load 137(f16bias)
+            5504:    7(fvec4) ImageSampleImplicitLod 5501 5502 Bias 5503
+            5505:    7(fvec4) Load 5452(texel)
+            5506:    7(fvec4) FAdd 5505 5504
+                              Store 5452(texel) 5506
+            5509:         183 Load 5508(tCube)
+            5510:        5456 Load 5458(s)
+            5511:         184 SampledImage 5509 5510
+            5512:  167(fvec3) Load 169(c3)
+            5513:    7(fvec4) ImageSampleImplicitLod 5511 5512
+            5514:    7(fvec4) Load 5452(texel)
+            5515:    7(fvec4) FAdd 5514 5513
+                              Store 5452(texel) 5515
+            5516:         183 Load 5508(tCube)
+            5517:        5456 Load 5458(s)
+            5518:         184 SampledImage 5516 5517
+            5519:  175(fvec3) Load 177(f16c3)
+            5520:    6(float) Load 137(f16bias)
+            5521:    7(fvec4) ImageSampleImplicitLod 5518 5519 Bias 5520
+            5522:    7(fvec4) Load 5452(texel)
+            5523:    7(fvec4) FAdd 5522 5521
+                              Store 5452(texel) 5523
+            5524:         122 Load 5454(t1D)
+            5526:        5456 Load 5525(sShadow)
+            5527:         199 SampledImage 5524 5526
+            5528:  167(fvec3) Load 169(c3)
+            5529:   52(float) CompositeExtract 5528 2
+            5530:    6(float) ImageSampleDrefImplicitLod 5527 5528 5529
+            5531:    208(ptr) AccessChain 5452(texel) 207
+            5532:    6(float) Load 5531
+            5533:    6(float) FAdd 5532 5530
+            5534:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5534 5533
+            5535:         122 Load 5454(t1D)
+            5536:        5456 Load 5525(sShadow)
+            5537:         199 SampledImage 5535 5536
+            5538:  154(fvec2) Load 156(f16c2)
+            5539:   52(float) Load 215(compare)
+            5540:    6(float) Load 137(f16bias)
+            5541:    6(float) ImageSampleDrefImplicitLod 5537 5538 5539 Bias 5540
+            5542:    208(ptr) AccessChain 5452(texel) 207
+            5543:    6(float) Load 5542
+            5544:    6(float) FAdd 5543 5541
+            5545:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5545 5544
+            5546:         142 Load 5474(t2D)
+            5547:        5456 Load 5525(sShadow)
+            5548:         224 SampledImage 5546 5547
+            5549:  167(fvec3) Load 169(c3)
+            5550:   52(float) CompositeExtract 5549 2
+            5551:    6(float) ImageSampleDrefImplicitLod 5548 5549 5550
+            5552:    208(ptr) AccessChain 5452(texel) 207
+            5553:    6(float) Load 5552
+            5554:    6(float) FAdd 5553 5551
+            5555:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5555 5554
+            5556:         142 Load 5474(t2D)
+            5557:        5456 Load 5525(sShadow)
+            5558:         224 SampledImage 5556 5557
+            5559:  154(fvec2) Load 156(f16c2)
+            5560:   52(float) Load 215(compare)
+            5561:    6(float) Load 137(f16bias)
+            5562:    6(float) ImageSampleDrefImplicitLod 5558 5559 5560 Bias 5561
+            5563:    208(ptr) AccessChain 5452(texel) 207
+            5564:    6(float) Load 5563
+            5565:    6(float) FAdd 5564 5562
+            5566:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5566 5565
+            5567:         183 Load 5508(tCube)
+            5568:        5456 Load 5525(sShadow)
+            5569:         245 SampledImage 5567 5568
+            5570:  249(fvec4) Load 251(c4)
+            5571:   52(float) CompositeExtract 5570 3
+            5572:    6(float) ImageSampleDrefImplicitLod 5569 5570 5571
+            5573:    208(ptr) AccessChain 5452(texel) 207
+            5574:    6(float) Load 5573
+            5575:    6(float) FAdd 5574 5572
+            5576:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5576 5575
+            5577:         183 Load 5508(tCube)
+            5578:        5456 Load 5525(sShadow)
+            5579:         245 SampledImage 5577 5578
+            5580:  175(fvec3) Load 177(f16c3)
+            5581:   52(float) Load 215(compare)
+            5582:    6(float) Load 137(f16bias)
+            5583:    6(float) ImageSampleDrefImplicitLod 5579 5580 5581 Bias 5582
+            5584:    208(ptr) AccessChain 5452(texel) 207
+            5585:    6(float) Load 5584
+            5586:    6(float) FAdd 5585 5583
+            5587:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5587 5586
+            5590:         268 Load 5589(t1DArray)
+            5591:        5456 Load 5458(s)
+            5592:         269 SampledImage 5590 5591
+            5593:   53(fvec2) Load 148(c2)
+            5594:    7(fvec4) ImageSampleImplicitLod 5592 5593
+            5595:    7(fvec4) Load 5452(texel)
+            5596:    7(fvec4) FAdd 5595 5594
+                              Store 5452(texel) 5596
+            5597:         268 Load 5589(t1DArray)
+            5598:        5456 Load 5458(s)
+            5599:         269 SampledImage 5597 5598
+            5600:  154(fvec2) Load 156(f16c2)
+            5601:    6(float) Load 137(f16bias)
+            5602:    7(fvec4) ImageSampleImplicitLod 5599 5600 Bias 5601
+            5603:    7(fvec4) Load 5452(texel)
+            5604:    7(fvec4) FAdd 5603 5602
+                              Store 5452(texel) 5604
+            5607:         283 Load 5606(t2DArray)
+            5608:        5456 Load 5458(s)
+            5609:         284 SampledImage 5607 5608
+            5610:  167(fvec3) Load 169(c3)
+            5611:    7(fvec4) ImageSampleImplicitLod 5609 5610
+            5612:    7(fvec4) Load 5452(texel)
+            5613:    7(fvec4) FAdd 5612 5611
+                              Store 5452(texel) 5613
+            5614:         283 Load 5606(t2DArray)
+            5615:        5456 Load 5458(s)
+            5616:         284 SampledImage 5614 5615
+            5617:  175(fvec3) Load 177(f16c3)
+            5618:    6(float) Load 137(f16bias)
+            5619:    7(fvec4) ImageSampleImplicitLod 5616 5617 Bias 5618
+            5620:    7(fvec4) Load 5452(texel)
+            5621:    7(fvec4) FAdd 5620 5619
+                              Store 5452(texel) 5621
+            5624:         298 Load 5623(tCubeArray)
+            5625:        5456 Load 5458(s)
+            5626:         299 SampledImage 5624 5625
+            5627:  249(fvec4) Load 251(c4)
+            5628:    7(fvec4) ImageSampleImplicitLod 5626 5627
+            5629:    7(fvec4) Load 5452(texel)
+            5630:    7(fvec4) FAdd 5629 5628
+                              Store 5452(texel) 5630
+            5631:         298 Load 5623(tCubeArray)
+            5632:        5456 Load 5458(s)
+            5633:         299 SampledImage 5631 5632
+            5634:    7(fvec4) Load 309(f16c4)
+            5635:    6(float) Load 137(f16bias)
+            5636:    7(fvec4) ImageSampleImplicitLod 5633 5634 Bias 5635
+            5637:    7(fvec4) Load 5452(texel)
+            5638:    7(fvec4) FAdd 5637 5636
+                              Store 5452(texel) 5638
+            5639:         268 Load 5589(t1DArray)
+            5640:        5456 Load 5525(sShadow)
+            5641:         316 SampledImage 5639 5640
+            5642:  167(fvec3) Load 169(c3)
+            5643:   52(float) CompositeExtract 5642 2
+            5644:    6(float) ImageSampleDrefImplicitLod 5641 5642 5643
+            5645:    208(ptr) AccessChain 5452(texel) 207
+            5646:    6(float) Load 5645
+            5647:    6(float) FAdd 5646 5644
+            5648:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5648 5647
+            5649:         268 Load 5589(t1DArray)
+            5650:        5456 Load 5525(sShadow)
+            5651:         316 SampledImage 5649 5650
+            5652:  154(fvec2) Load 156(f16c2)
+            5653:   52(float) Load 215(compare)
+            5654:    6(float) Load 137(f16bias)
+            5655:    6(float) ImageSampleDrefImplicitLod 5651 5652 5653 Bias 5654
+            5656:    208(ptr) AccessChain 5452(texel) 207
+            5657:    6(float) Load 5656
+            5658:    6(float) FAdd 5657 5655
+            5659:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5659 5658
+            5660:         283 Load 5606(t2DArray)
+            5661:        5456 Load 5525(sShadow)
+            5662:         337 SampledImage 5660 5661
+            5663:  249(fvec4) Load 251(c4)
+            5664:   52(float) CompositeExtract 5663 3
+            5665:    6(float) ImageSampleDrefImplicitLod 5662 5663 5664
+            5666:    208(ptr) AccessChain 5452(texel) 207
+            5667:    6(float) Load 5666
+            5668:    6(float) FAdd 5667 5665
+            5669:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5669 5668
+            5670:         283 Load 5606(t2DArray)
+            5671:        5456 Load 5525(sShadow)
+            5672:         337 SampledImage 5670 5671
+            5673:  175(fvec3) Load 177(f16c3)
+            5674:   52(float) Load 215(compare)
+            5675:    6(float) ImageSampleDrefImplicitLod 5672 5673 5674
+            5676:    208(ptr) AccessChain 5452(texel) 207
+            5677:    6(float) Load 5676
+            5678:    6(float) FAdd 5677 5675
+            5679:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5679 5678
+            5682:         356 Load 5681(t2DRect)
+            5683:        5456 Load 5458(s)
+            5684:         357 SampledImage 5682 5683
+            5685:   53(fvec2) Load 148(c2)
+            5686:    7(fvec4) ImageSampleImplicitLod 5684 5685
+            5687:    7(fvec4) Load 5452(texel)
+            5688:    7(fvec4) FAdd 5687 5686
+                              Store 5452(texel) 5688
+            5689:         356 Load 5681(t2DRect)
+            5690:        5456 Load 5458(s)
+            5691:         357 SampledImage 5689 5690
+            5692:  154(fvec2) Load 156(f16c2)
+            5693:    7(fvec4) ImageSampleImplicitLod 5691 5692
+            5694:    7(fvec4) Load 5452(texel)
+            5695:    7(fvec4) FAdd 5694 5693
+                              Store 5452(texel) 5695
+            5696:         356 Load 5681(t2DRect)
+            5697:        5456 Load 5525(sShadow)
+            5698:         371 SampledImage 5696 5697
+            5699:  167(fvec3) Load 169(c3)
+            5700:   52(float) CompositeExtract 5699 2
+            5701:    6(float) ImageSampleDrefImplicitLod 5698 5699 5700
+            5702:    208(ptr) AccessChain 5452(texel) 207
+            5703:    6(float) Load 5702
+            5704:    6(float) FAdd 5703 5701
+            5705:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5705 5704
+            5706:         356 Load 5681(t2DRect)
+            5707:        5456 Load 5525(sShadow)
+            5708:         371 SampledImage 5706 5707
+            5709:  154(fvec2) Load 156(f16c2)
+            5710:   52(float) Load 215(compare)
+            5711:    6(float) ImageSampleDrefImplicitLod 5708 5709 5710
+            5712:    208(ptr) AccessChain 5452(texel) 207
+            5713:    6(float) Load 5712
+            5714:    6(float) FAdd 5713 5711
+            5715:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5715 5714
+            5716:         298 Load 5623(tCubeArray)
+            5717:        5456 Load 5525(sShadow)
+            5718:         391 SampledImage 5716 5717
+            5719:  249(fvec4) Load 251(c4)
+            5720:   52(float) Load 215(compare)
+            5721:    6(float) ImageSampleDrefImplicitLod 5718 5719 5720
+            5722:    208(ptr) AccessChain 5452(texel) 207
+            5723:    6(float) Load 5722
+            5724:    6(float) FAdd 5723 5721
+            5725:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5725 5724
+            5726:         298 Load 5623(tCubeArray)
+            5727:        5456 Load 5525(sShadow)
+            5728:         391 SampledImage 5726 5727
+            5729:    7(fvec4) Load 309(f16c4)
+            5730:   52(float) Load 215(compare)
+            5731:    6(float) ImageSampleDrefImplicitLod 5728 5729 5730
+            5732:    208(ptr) AccessChain 5452(texel) 207
+            5733:    6(float) Load 5732
+            5734:    6(float) FAdd 5733 5731
+            5735:    208(ptr) AccessChain 5452(texel) 207
+                              Store 5735 5734
+            5736:    7(fvec4) Load 5452(texel)
+                              ReturnValue 5736
+                              FunctionEnd
+117(testSubpassLoad():    7(fvec4) Function None 8
+             118:             Label
+            5742:        5739 Load 5741(subpass)
+            5744:    7(fvec4) ImageRead 5742 5743
+            5748:        5745 Load 5747(subpassMS)
+            5749:    7(fvec4) ImageRead 5748 5743 Sample 1326
+            5750:    7(fvec4) FAdd 5744 5749
+                              ReturnValue 5750
+                              FunctionEnd

+ 1273 - 0
Test/spv.float16Fetch.frag

@@ -0,0 +1,1273 @@
+#version 450 core
+
+#extension GL_ARB_sparse_texture2: enable
+#extension GL_ARB_sparse_texture_clamp: enable
+#extension GL_AMD_gpu_shader_half_float: enable
+#extension GL_AMD_gpu_shader_half_float_fetch: enable
+#extension GL_AMD_texture_gather_bias_lod: enable
+
+layout(set = 0, binding =  0) uniform f16sampler1D            s1D;
+layout(set = 0, binding =  1) uniform f16sampler2D            s2D;
+layout(set = 0, binding =  2) uniform f16sampler3D            s3D;
+layout(set = 0, binding =  3) uniform f16sampler2DRect        s2DRect;
+layout(set = 0, binding =  4) uniform f16samplerCube          sCube;
+layout(set = 0, binding =  5) uniform f16samplerBuffer        sBuffer;
+layout(set = 0, binding =  6) uniform f16sampler2DMS          s2DMS;
+layout(set = 0, binding =  7) uniform f16sampler1DArray       s1DArray;
+layout(set = 0, binding =  8) uniform f16sampler2DArray       s2DArray;
+layout(set = 0, binding =  9) uniform f16samplerCubeArray     sCubeArray;
+layout(set = 0, binding = 10) uniform f16sampler2DMSArray     s2DMSArray;
+
+layout(set = 0, binding = 11) uniform f16sampler1DShadow          s1DShadow;
+layout(set = 0, binding = 12) uniform f16sampler2DShadow          s2DShadow;
+layout(set = 0, binding = 13) uniform f16sampler2DRectShadow      s2DRectShadow;
+layout(set = 0, binding = 14) uniform f16samplerCubeShadow        sCubeShadow;
+layout(set = 0, binding = 15) uniform f16sampler1DArrayShadow     s1DArrayShadow;
+layout(set = 0, binding = 16) uniform f16sampler2DArrayShadow     s2DArrayShadow;
+layout(set = 0, binding = 17) uniform f16samplerCubeArrayShadow   sCubeArrayShadow;
+
+layout(set = 1, binding =  0) layout(rgba16f) uniform f16image1D          i1D;
+layout(set = 1, binding =  1) layout(rgba16f) uniform f16image2D          i2D;
+layout(set = 1, binding =  2) layout(rgba16f) uniform f16image3D          i3D;
+layout(set = 1, binding =  3) layout(rgba16f) uniform f16image2DRect      i2DRect;
+layout(set = 1, binding =  4) layout(rgba16f) uniform f16imageCube        iCube;
+layout(set = 1, binding =  5) layout(rgba16f) uniform f16image1DArray     i1DArray;
+layout(set = 1, binding =  6) layout(rgba16f) uniform f16image2DArray     i2DArray;
+layout(set = 1, binding =  7) layout(rgba16f) uniform f16imageCubeArray   iCubeArray;
+layout(set = 1, binding =  8) layout(rgba16f) uniform f16imageBuffer      iBuffer;
+layout(set = 1, binding =  9) layout(rgba16f) uniform f16image2DMS        i2DMS;
+layout(set = 1, binding = 10) layout(rgba16f) uniform f16image2DMSArray   i2DMSArray;
+
+layout(set = 2, binding =  0) uniform f16texture1D           t1D;
+layout(set = 2, binding =  1) uniform f16texture2D           t2D;
+layout(set = 2, binding =  2) uniform f16texture3D           t3D;
+layout(set = 2, binding =  3) uniform f16texture2DRect       t2DRect;
+layout(set = 2, binding =  4) uniform f16textureCube         tCube;
+layout(set = 2, binding =  5) uniform f16texture1DArray      t1DArray;
+layout(set = 2, binding =  6) uniform f16texture2DArray      t2DArray;
+layout(set = 2, binding =  7) uniform f16textureCubeArray    tCubeArray;
+layout(set = 2, binding =  8) uniform f16textureBuffer       tBuffer;
+layout(set = 2, binding =  9) uniform f16texture2DMS         t2DMS;
+layout(set = 2, binding = 10) uniform f16texture2DMSArray    t2DMSArray;
+
+layout(set = 2, binding = 11) uniform sampler s;
+layout(set = 2, binding = 12) uniform samplerShadow sShadow;
+
+layout(set = 3, binding = 0, input_attachment_index = 0) uniform f16subpassInput   subpass;
+layout(set = 3, binding = 1, input_attachment_index = 0) uniform f16subpassInputMS subpassMS;
+
+layout(location =  0) in float c1;
+layout(location =  1) in vec2  c2;
+layout(location =  2) in vec3  c3;
+layout(location =  3) in vec4  c4;
+
+layout(location =  4) in float compare;
+layout(location =  5) in float lod;
+layout(location =  6) in float bias;
+layout(location =  7) in float lodClamp;
+
+layout(location =  8) in float dPdxy1;
+layout(location =  9) in vec2  dPdxy2;
+layout(location = 10) in vec3  dPdxy3;
+
+layout(location = 11) in float16_t f16c1;
+layout(location = 12) in f16vec2   f16c2;
+layout(location = 13) in f16vec3   f16c3;
+layout(location = 14) in f16vec4   f16c4;
+
+layout(location = 15) in float16_t f16lod;
+layout(location = 16) in float16_t f16bias;
+layout(location = 17) in float16_t f16lodClamp;
+
+layout(location = 18) in float16_t f16dPdxy1;
+layout(location = 19) in f16vec2   f16dPdxy2;
+layout(location = 20) in f16vec3   f16dPdxy3;
+
+const int   offset1 = 1;
+const ivec2 offset2 = ivec2(1);
+const ivec3 offset3 = ivec3(1);
+const ivec2 offsets[4] = { offset2, offset2, offset2, offset2 };
+
+layout(location = 0) out vec4 fragColor;
+
+f16vec4 testTexture()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += texture(s1D, c1);
+    texel   += texture(s1D, f16c1, f16bias);
+    texel   += texture(s2D, c2);
+    texel   += texture(s2D, f16c2, f16bias);
+    texel   += texture(s3D, c3);
+    texel   += texture(s3D, f16c3, f16bias);
+    texel   += texture(sCube, c3);
+    texel   += texture(sCube, f16c3, f16bias);
+    texel.x += texture(s1DShadow, c3);
+    texel.x += texture(s1DShadow, f16c2, compare, f16bias);
+    texel.x += texture(s2DShadow, c3);
+    texel.x += texture(s2DShadow, f16c2, compare, f16bias);
+    texel.x += texture(sCubeShadow, c4);
+    texel.x += texture(sCubeShadow, f16c3, compare, f16bias);
+    texel   += texture(s1DArray, c2);
+    texel   += texture(s1DArray, f16c2, f16bias);
+    texel   += texture(s2DArray, c3);
+    texel   += texture(s2DArray, f16c3, f16bias);
+    texel   += texture(sCubeArray, c4);
+    texel   += texture(sCubeArray, f16c4, f16bias);
+    texel.x += texture(s1DArrayShadow, c3);
+    texel.x += texture(s1DArrayShadow, f16c2, compare, f16bias);
+    texel.x += texture(s2DArrayShadow, c4);
+    texel.x += texture(s2DArrayShadow, f16c3, compare);
+    texel   += texture(s2DRect, c2);
+    texel   += texture(s2DRect, f16c2);
+    texel.x += texture(s2DRectShadow, c3);
+    texel.x += texture(s2DRectShadow, f16c2, compare);
+    texel.x += texture(sCubeArrayShadow, c4, compare);
+    texel.x += texture(sCubeArrayShadow, f16c4, compare);
+
+    return texel;
+}
+
+f16vec4 testTextureProj()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureProj(s1D, c2);
+    texel   += textureProj(s1D, f16c2, f16bias);
+    texel   += textureProj(s1D, c4);
+    texel   += textureProj(s1D, f16c4, f16bias);
+    texel   += textureProj(s2D, c3);
+    texel   += textureProj(s2D, f16c3, f16bias);
+    texel   += textureProj(s2D, c4);
+    texel   += textureProj(s2D, f16c4, f16bias);
+    texel   += textureProj(s3D, c4);
+    texel   += textureProj(s3D, f16c4, f16bias);
+    texel.x += textureProj(s1DShadow, c4);
+    texel.x += textureProj(s1DShadow, f16c3, compare, f16bias);
+    texel.x += textureProj(s2DShadow, c4);
+    texel.x += textureProj(s2DShadow, f16c3, compare, f16bias);
+    texel   += textureProj(s2DRect, c3);
+    texel   += textureProj(s2DRect, f16c3);
+    texel   += textureProj(s2DRect, c4);
+    texel   += textureProj(s2DRect, f16c4);
+    texel.x += textureProj(s2DRectShadow, c4);
+    texel.x += textureProj(s2DRectShadow, f16c3, compare);
+
+    return texel;
+}
+
+f16vec4 testTextureLod()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureLod(s1D, c1, lod);
+    texel   += textureLod(s1D, f16c1, f16lod);
+    texel   += textureLod(s2D, c2, lod);
+    texel   += textureLod(s2D, f16c2, f16lod);
+    texel   += textureLod(s3D, c3, lod);
+    texel   += textureLod(s3D, f16c3, f16lod);
+    texel   += textureLod(sCube, c3, lod);
+    texel   += textureLod(sCube, f16c3, f16lod);
+    texel.x += textureLod(s1DShadow, c3, lod);
+    texel.x += textureLod(s1DShadow, f16c2, compare, f16lod);
+    texel.x += textureLod(s2DShadow, c3, lod);
+    texel.x += textureLod(s2DShadow, f16c2, compare, f16lod);
+    texel   += textureLod(s1DArray, c2, lod);
+    texel   += textureLod(s1DArray, f16c2, f16lod);
+    texel   += textureLod(s2DArray, c3, lod);
+    texel   += textureLod(s2DArray, f16c3, f16lod);
+    texel.x += textureLod(s1DArrayShadow, c3, lod);
+    texel.x += textureLod(s1DArrayShadow, f16c2, compare, f16lod);
+    texel   += textureLod(sCubeArray, c4, lod);
+    texel   += textureLod(sCubeArray, f16c4, f16lod);
+
+    return texel;
+}
+
+f16vec4 testTextureOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureOffset(s1D, c1, offset1);
+    texel   += textureOffset(s1D, f16c1, offset1, f16bias);
+    texel   += textureOffset(s2D, c2, offset2);
+    texel   += textureOffset(s2D, f16c2, offset2, f16bias);
+    texel   += textureOffset(s3D, c3, offset3);
+    texel   += textureOffset(s3D, f16c3, offset3, f16bias);
+    texel   += textureOffset(s2DRect, c2, offset2);
+    texel   += textureOffset(s2DRect, f16c2, offset2);
+    texel.x += textureOffset(s2DRectShadow, c3, offset2);
+    texel.x += textureOffset(s2DRectShadow, f16c2, compare, offset2);
+    texel.x += textureOffset(s1DShadow, c3, offset1);
+    texel.x += textureOffset(s1DShadow, f16c2, compare, offset1, f16bias);
+    texel.x += textureOffset(s2DShadow, c3, offset2);
+    texel.x += textureOffset(s2DShadow, f16c2, compare, offset2, f16bias);
+    texel   += textureOffset(s1DArray, c2, offset1);
+    texel   += textureOffset(s1DArray, f16c2, offset1, f16bias);
+    texel   += textureOffset(s2DArray, c3, offset2);
+    texel   += textureOffset(s2DArray, f16c3, offset2, f16bias);
+    texel.x += textureOffset(s1DArrayShadow, c3, offset1);
+    texel.x += textureOffset(s1DArrayShadow, f16c2, compare, offset1, f16bias);
+    texel.x += textureOffset(s2DArrayShadow, c4, offset2);
+    texel.x += textureOffset(s2DArrayShadow, f16c3, compare, offset2);
+
+    return texel;
+}
+
+f16vec4 testTextureProjOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureProjOffset(s1D, c2, offset1);
+    texel   += textureProjOffset(s1D, f16c2, offset1, f16bias);
+    texel   += textureProjOffset(s1D, c4, offset1);
+    texel   += textureProjOffset(s1D, f16c4, offset1, f16bias);
+    texel   += textureProjOffset(s2D, c3, offset2);
+    texel   += textureProjOffset(s2D, f16c3, offset2, f16bias);
+    texel   += textureProjOffset(s2D, c4, offset2);
+    texel   += textureProjOffset(s2D, f16c4, offset2, f16bias);
+    texel   += textureProjOffset(s3D, c4, offset3);
+    texel   += textureProjOffset(s3D, f16c4, offset3, f16bias);
+    texel   += textureProjOffset(s2DRect, c3, offset2);
+    texel   += textureProjOffset(s2DRect, f16c3, offset2);
+    texel   += textureProjOffset(s2DRect, c4, offset2);
+    texel   += textureProjOffset(s2DRect, f16c4, offset2);
+    texel.x += textureProjOffset(s2DRectShadow, c4, offset2);
+    texel.x += textureProjOffset(s2DRectShadow, f16c3, compare, offset2);
+    texel.x += textureProjOffset(s1DShadow, c4, offset1);
+    texel.x += textureProjOffset(s1DShadow, f16c3, compare, offset1, f16bias);
+    texel.x += textureProjOffset(s2DShadow, c4, offset2);
+    texel.x += textureProjOffset(s2DShadow, f16c3, compare, offset2, f16bias); 
+
+    return texel;
+}
+
+f16vec4 testTextureLodOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureLodOffset(s1D, c1, lod, offset1);
+    texel   += textureLodOffset(s1D, f16c1, f16lod, offset1);
+    texel   += textureLodOffset(s2D, c2, lod, offset2);
+    texel   += textureLodOffset(s2D, f16c2, f16lod, offset2);
+    texel   += textureLodOffset(s3D, c3, lod, offset3);
+    texel   += textureLodOffset(s3D, f16c3, f16lod, offset3);
+    texel.x += textureLodOffset(s1DShadow, c3, lod, offset1);
+    texel.x += textureLodOffset(s1DShadow, f16c2, compare, f16lod, offset1);
+    texel.x += textureLodOffset(s2DShadow, c3, lod, offset2);
+    texel.x += textureLodOffset(s2DShadow, f16c2, compare, f16lod, offset2);
+    texel   += textureLodOffset(s1DArray, c2, lod, offset1);
+    texel   += textureLodOffset(s1DArray, f16c2, f16lod, offset1);
+    texel   += textureLodOffset(s2DArray, c3, lod, offset2);
+    texel   += textureLodOffset(s2DArray, f16c3, f16lod, offset2);
+    texel.x += textureLodOffset(s1DArrayShadow, c3, lod, offset1);
+    texel.x += textureLodOffset(s1DArrayShadow, f16c2, compare, f16lod, offset1);
+
+    return texel;
+}
+
+f16vec4 testTextureProjLodOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureProjLodOffset(s1D, c2, lod, offset1);
+    texel   += textureProjLodOffset(s1D, f16c2, f16lod, offset1);
+    texel   += textureProjLodOffset(s1D, c4, lod, offset1);
+    texel   += textureProjLodOffset(s1D, f16c4, f16lod, offset1);
+    texel   += textureProjLodOffset(s2D, c3, lod, offset2);
+    texel   += textureProjLodOffset(s2D, f16c3, f16lod, offset2);
+    texel   += textureProjLodOffset(s2D, c4, lod, offset2);
+    texel   += textureProjLodOffset(s2D, f16c4, f16lod, offset2);
+    texel   += textureProjLodOffset(s3D, c4, lod, offset3);
+    texel   += textureProjLodOffset(s3D, f16c4, f16lod, offset3);
+    texel.x += textureProjLodOffset(s1DShadow, c4, lod, offset1);
+    texel.x += textureProjLodOffset(s1DShadow, f16c3, compare, f16lod, offset1);
+    texel.x += textureProjLodOffset(s2DShadow, c4, lod, offset2);
+    texel.x += textureProjLodOffset(s2DShadow, f16c3, compare, f16lod, offset2);
+
+    return texel;
+}
+
+f16vec4 testTexelFetch()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += texelFetch(s1D, int(c1), int(lod));
+    texel   += texelFetch(s2D, ivec2(c2), int(lod));
+    texel   += texelFetch(s3D, ivec3(c3), int(lod));
+    texel   += texelFetch(s2DRect, ivec2(c2));
+    texel   += texelFetch(s1DArray, ivec2(c2), int(lod));
+    texel   += texelFetch(s2DArray, ivec3(c3), int(lod));
+    texel   += texelFetch(sBuffer, int(c1));
+    texel   += texelFetch(s2DMS, ivec2(c2), 1);
+    texel   += texelFetch(s2DMSArray, ivec3(c3), 2);
+
+    return texel;
+}
+
+f16vec4 testTexelFetchOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += texelFetchOffset(s1D, int(c1), int(lod), offset1);
+    texel   += texelFetchOffset(s2D, ivec2(c2), int(lod), offset2);
+    texel   += texelFetchOffset(s3D, ivec3(c3), int(lod), offset3);
+    texel   += texelFetchOffset(s2DRect, ivec2(c2), offset2);
+    texel   += texelFetchOffset(s1DArray, ivec2(c2), int(lod), offset1);
+    texel   += texelFetchOffset(s2DArray, ivec3(c3), int(lod), offset2);
+
+    return texel;
+}
+
+f16vec4 testTextureGrad()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGrad(s1D, c1, dPdxy1, dPdxy1);
+    texel   += textureGrad(s1D, f16c1, f16dPdxy1, f16dPdxy1);
+    texel   += textureGrad(s2D, c2, dPdxy2, dPdxy2);
+    texel   += textureGrad(s2D, f16c2, f16dPdxy2, f16dPdxy2);
+    texel   += textureGrad(s3D, c3, dPdxy3, dPdxy3);
+    texel   += textureGrad(s3D, f16c3, f16dPdxy3, f16dPdxy3);
+    texel   += textureGrad(sCube, c3, dPdxy3, dPdxy3);
+    texel   += textureGrad(sCube, f16c3, f16dPdxy3, f16dPdxy3);
+    texel   += textureGrad(s2DRect, c2, dPdxy2, dPdxy2);
+    texel   += textureGrad(s2DRect, f16c2, f16dPdxy2, f16dPdxy2);
+    texel.x += textureGrad(s2DRectShadow, c3, dPdxy2, dPdxy2);
+    texel.x += textureGrad(s2DRectShadow, f16c2, compare, f16dPdxy2, f16dPdxy2);
+    texel.x += textureGrad(s1DShadow, c3, dPdxy1, dPdxy1);
+    texel.x += textureGrad(s1DShadow, f16c2, compare, f16dPdxy1, f16dPdxy1);
+    texel.x += textureGrad(s2DShadow, c3, dPdxy2, dPdxy2);
+    texel.x += textureGrad(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2);
+    texel.x += textureGrad(sCubeShadow, c4, dPdxy3, dPdxy3);
+    texel.x += textureGrad(sCubeShadow, f16c3, compare, f16dPdxy3, f16dPdxy3);
+    texel   += textureGrad(s1DArray, c2, dPdxy1, dPdxy1);
+    texel   += textureGrad(s1DArray, f16c2, f16dPdxy1, f16dPdxy1);
+    texel   += textureGrad(s2DArray, c3, dPdxy2, dPdxy2);
+    texel   += textureGrad(s2DArray, f16c3, f16dPdxy2, f16dPdxy2);
+    texel.x += textureGrad(s1DArrayShadow, c3, dPdxy1, dPdxy1);
+    texel.x += textureGrad(s1DArrayShadow, f16c2, compare, f16dPdxy1, f16dPdxy1);
+    texel.x += textureGrad(s2DArrayShadow, c4, dPdxy2, dPdxy2);
+    texel.x += textureGrad(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2);
+    texel   += textureGrad(sCubeArray, c4, dPdxy3, dPdxy3);
+    texel   += textureGrad(sCubeArray, f16c4, f16dPdxy3, f16dPdxy3);
+
+    return texel;
+}
+
+f16vec4 testTextureGradOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGradOffset(s1D, c1, dPdxy1, dPdxy1, offset1);
+    texel   += textureGradOffset(s1D, f16c1, f16dPdxy1, f16dPdxy1, offset1);
+    texel   += textureGradOffset(s2D, c2, dPdxy2, dPdxy2, offset2);
+    texel   += textureGradOffset(s2D, f16c2, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureGradOffset(s3D, c3, dPdxy3, dPdxy3, offset3);
+    texel   += textureGradOffset(s3D, f16c3, f16dPdxy3, f16dPdxy3, offset3);
+    texel   += textureGradOffset(s2DRect, c2, dPdxy2, dPdxy2, offset2);
+    texel   += textureGradOffset(s2DRect, f16c2, f16dPdxy2, f16dPdxy2, offset2);
+    texel.x += textureGradOffset(s2DRectShadow, c3, dPdxy2, dPdxy2, offset2);
+    texel.x += textureGradOffset(s2DRectShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2);
+    texel.x += textureGradOffset(s1DShadow, c3, dPdxy1, dPdxy1, offset1);
+    texel.x += textureGradOffset(s1DShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, offset1);
+    texel.x += textureGradOffset(s2DShadow, c3, dPdxy2, dPdxy2, offset2);
+    texel.x += textureGradOffset(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureGradOffset(s1DArray, c2, dPdxy1, dPdxy1, offset1);
+    texel   += textureGradOffset(s1DArray, f16c2, f16dPdxy1, f16dPdxy1, offset1);
+    texel   += textureGradOffset(s2DArray, c3, dPdxy2, dPdxy2, offset2);
+    texel   += textureGradOffset(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, offset2);
+    texel.x += textureGradOffset(s1DArrayShadow, c3, dPdxy1, dPdxy1, offset1);
+    texel.x += textureGradOffset(s1DArrayShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, offset1);
+    texel.x += textureGradOffset(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2);
+    texel.x += textureGradOffset(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2);
+
+    return texel;
+}
+
+f16vec4 testTextureProjGrad()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureProjGrad(s1D, c2, dPdxy1, dPdxy1);
+    texel   += textureProjGrad(s1D, f16c2, f16dPdxy1, f16dPdxy1);
+    texel   += textureProjGrad(s1D, c4, dPdxy1, dPdxy1);
+    texel   += textureProjGrad(s1D, f16c4, f16dPdxy1, f16dPdxy1);
+    texel   += textureProjGrad(s2D, c3, dPdxy2, dPdxy2);
+    texel   += textureProjGrad(s2D, f16c3, f16dPdxy2, f16dPdxy2);
+    texel   += textureProjGrad(s2D, c4, dPdxy2, dPdxy2);
+    texel   += textureProjGrad(s2D, f16c4, f16dPdxy2, f16dPdxy2);
+    texel   += textureProjGrad(s3D, c4, dPdxy3, dPdxy3);
+    texel   += textureProjGrad(s3D, f16c4, f16dPdxy3, f16dPdxy3);
+    texel   += textureProjGrad(s2DRect, c3, dPdxy2, dPdxy2);
+    texel   += textureProjGrad(s2DRect, f16c3, f16dPdxy2, f16dPdxy2);
+    texel   += textureProjGrad(s2DRect, c4, dPdxy2, dPdxy2);
+    texel   += textureProjGrad(s2DRect, f16c4, f16dPdxy2, f16dPdxy2);
+    texel.x += textureProjGrad(s2DRectShadow, c4, dPdxy2, dPdxy2);
+    texel.x += textureProjGrad(s2DRectShadow, f16c3, compare, f16dPdxy2, f16dPdxy2);
+    texel.x += textureProjGrad(s1DShadow, c4, dPdxy1, dPdxy1);
+    texel.x += textureProjGrad(s1DShadow, f16c3, compare, f16dPdxy1, f16dPdxy1);
+    texel.x += textureProjGrad(s2DShadow, c4, dPdxy2, dPdxy2);
+    texel.x += textureProjGrad(s2DShadow, f16c3, compare, f16dPdxy2, f16dPdxy2);
+
+    return texel;
+}
+
+f16vec4 testTextureProjGradoffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureProjGradOffset(s1D, c2, dPdxy1, dPdxy1, offset1);
+    texel   += textureProjGradOffset(s1D, f16c2, f16dPdxy1, f16dPdxy1, offset1);
+    texel   += textureProjGradOffset(s1D, c4, dPdxy1, dPdxy1, offset1);
+    texel   += textureProjGradOffset(s1D, f16c4, f16dPdxy1, f16dPdxy1, offset1);
+    texel   += textureProjGradOffset(s2D, c3, dPdxy2, dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2D, f16c3, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2D, c4, dPdxy2, dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2D, f16c4, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2DRect, c3, dPdxy2, dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2DRect, f16c3, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2DRect, c4, dPdxy2, dPdxy2, offset2);
+    texel   += textureProjGradOffset(s2DRect, f16c4, f16dPdxy2, f16dPdxy2, offset2);
+    texel.x += textureProjGradOffset(s2DRectShadow, c4, dPdxy2, dPdxy2, offset2);
+    texel.x += textureProjGradOffset(s2DRectShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2);
+    texel   += textureProjGradOffset(s3D, c4, dPdxy3, dPdxy3, offset3);
+    texel   += textureProjGradOffset(s3D, f16c4, f16dPdxy3, f16dPdxy3, offset3);
+    texel.x += textureProjGradOffset(s1DShadow, c4, dPdxy1, dPdxy1, offset1);
+    texel.x += textureProjGradOffset(s1DShadow, f16c3, compare, f16dPdxy1, f16dPdxy1, offset1);
+    texel.x += textureProjGradOffset(s2DShadow, c4, dPdxy2, dPdxy2, offset2);
+    texel.x += textureProjGradOffset(s2DShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2);
+
+    return texel;
+}
+
+f16vec4 testTextureGather()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGather(s2D, c2, 0);
+    texel   += textureGather(s2D, f16c2, 0, f16bias);
+    texel   += textureGather(s2DArray, c3, 0);
+    texel   += textureGather(s2DArray, f16c3, 0, f16bias);
+    texel   += textureGather(sCube, c3, 0);
+    texel   += textureGather(sCube, f16c3, 0, f16bias);
+    texel   += textureGather(sCubeArray, c4, 0);
+    texel   += textureGather(sCubeArray, f16c4, 0, f16bias);
+    texel   += textureGather(s2DRect, c2, 0);
+    texel   += textureGather(s2DRect, f16c2, 0);
+    texel   += textureGather(s2DShadow, c2, compare);
+    texel   += textureGather(s2DShadow, f16c2, compare);
+    texel   += textureGather(s2DArrayShadow, c3, compare);
+    texel   += textureGather(s2DArrayShadow, f16c3, compare);
+    texel   += textureGather(sCubeShadow, c3, compare);
+    texel   += textureGather(sCubeShadow, f16c3, compare);
+    texel   += textureGather(sCubeArrayShadow, c4, compare);
+    texel   += textureGather(sCubeArrayShadow, f16c4, compare);
+    texel   += textureGather(s2DRectShadow, c2, compare);
+    texel   += textureGather(s2DRectShadow, f16c2, compare);
+
+    return texel;
+}
+
+f16vec4 testTextureGatherOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGatherOffset(s2D, c2, offset2, 0);
+    texel   += textureGatherOffset(s2D, f16c2, offset2, 0, f16bias);
+    texel   += textureGatherOffset(s2DArray, c3, offset2, 0);
+    texel   += textureGatherOffset(s2DArray, f16c3, offset2, 0, f16bias);
+    texel   += textureGatherOffset(s2DRect, c2, offset2, 0);
+    texel   += textureGatherOffset(s2DRect, f16c2, offset2, 0);
+    texel   += textureGatherOffset(s2DShadow, c2, compare, offset2);
+    texel   += textureGatherOffset(s2DShadow, f16c2, compare, offset2);
+    texel   += textureGatherOffset(s2DArrayShadow, c3, compare, offset2);
+    texel   += textureGatherOffset(s2DArrayShadow, f16c3, compare, offset2);
+    texel   += textureGatherOffset(s2DRectShadow, c2, compare, offset2);
+    texel   += textureGatherOffset(s2DRectShadow, f16c2, compare, offset2);
+
+    return texel;
+}
+
+f16vec4 testTextureGatherOffsets()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGatherOffsets(s2D, c2, offsets, 0);
+    texel   += textureGatherOffsets(s2D, f16c2, offsets, 0, f16bias);
+    texel   += textureGatherOffsets(s2DArray, c3, offsets, 0);
+    texel   += textureGatherOffsets(s2DArray, f16c3, offsets, 0, f16bias);
+    texel   += textureGatherOffsets(s2DRect, c2, offsets, 0);
+    texel   += textureGatherOffsets(s2DRect, f16c2, offsets, 0);
+    texel   += textureGatherOffsets(s2DShadow, c2, compare, offsets);
+    texel   += textureGatherOffsets(s2DShadow, f16c2, compare, offsets);
+    texel   += textureGatherOffsets(s2DArrayShadow, c3, compare, offsets);
+    texel   += textureGatherOffsets(s2DArrayShadow, f16c3, compare, offsets);
+    texel   += textureGatherOffsets(s2DRectShadow, c2, compare, offsets);
+    texel   += textureGatherOffsets(s2DRectShadow, f16c2, compare, offsets);
+
+    return texel;
+}
+
+f16vec4 testTextureGatherLod()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGatherLodAMD(s2D, c2, lod, 0);
+    texel   += textureGatherLodAMD(s2D, f16c2, f16lod, 0);
+    texel   += textureGatherLodAMD(s2DArray, c3, lod, 0);
+    texel   += textureGatherLodAMD(s2DArray, f16c3, f16lod, 0);
+    texel   += textureGatherLodAMD(sCube, c3, lod, 0);
+    texel   += textureGatherLodAMD(sCube, f16c3, f16lod, 0);
+    texel   += textureGatherLodAMD(sCubeArray, c4, lod, 0);
+    texel   += textureGatherLodAMD(sCubeArray, f16c4, f16lod, 0);
+
+    return texel;
+}
+
+f16vec4 testTextureGatherLodOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGatherLodOffsetAMD(s2D, c2, lod, offset2, 0);
+    texel   += textureGatherLodOffsetAMD(s2D, f16c2, f16lod, offset2, 0);
+    texel   += textureGatherLodOffsetAMD(s2DArray, c3, lod, offset2, 0);
+    texel   += textureGatherLodOffsetAMD(s2DArray, f16c3, f16lod, offset2, 0);
+
+    return texel;
+}
+
+f16vec4 testTextureGatherLodOffsets()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGatherLodOffsetsAMD(s2D, c2, lod, offsets, 0);
+    texel   += textureGatherLodOffsetsAMD(s2D, f16c2, f16lod, offsets, 0);
+    texel   += textureGatherLodOffsetsAMD(s2DArray, c3, lod, offsets, 0);
+    texel   += textureGatherLodOffsetsAMD(s2DArray, f16c3, f16lod, offsets, 0);
+
+    return texel;
+}
+
+ivec4 testTextureSize()
+{
+    ivec4 size = ivec4(0);
+
+    size.x      += textureSize(s1D, int(lod));
+    size.xy     += textureSize(s2D, int(lod));
+    size.xyz    += textureSize(s3D, int(lod));
+    size.xy     += textureSize(sCube, int(lod));
+    size.x      += textureSize(s1DShadow, int(lod));
+    size.xy     += textureSize(s2DShadow, int(lod));
+    size.xy     += textureSize(sCubeShadow, int(lod));
+    size.xyz    += textureSize(sCubeArray, int(lod));
+    size.xyz    += textureSize(sCubeArrayShadow, int(lod));
+    size.xy     += textureSize(s2DRect);
+    size.xy     += textureSize(s2DRectShadow);
+    size.xy     += textureSize(s1DArray, int(lod));
+    size.xyz    += textureSize(s2DArray, int(lod));
+    size.xy     += textureSize(s1DArrayShadow, int(lod));
+    size.xyz    += textureSize(s2DArrayShadow, int(lod));
+    size.x      += textureSize(sBuffer);
+    size.xy     += textureSize(s2DMS);
+    size.xyz    += textureSize(s2DMSArray);
+
+    return size;
+}
+
+vec2 testTextureQueryLod()
+{
+    vec2 lod = vec2(0.0);
+
+    lod  += textureQueryLod(s1D, c1);
+    lod  += textureQueryLod(s1D, f16c1);
+    lod  += textureQueryLod(s2D, c2);
+    lod  += textureQueryLod(s2D, f16c2);
+    lod  += textureQueryLod(s3D, c3);
+    lod  += textureQueryLod(s3D, f16c3);
+    lod  += textureQueryLod(sCube, c3);
+    lod  += textureQueryLod(sCube, f16c3);
+    lod  += textureQueryLod(s1DArray, c1);
+    lod  += textureQueryLod(s1DArray, f16c1);
+    lod  += textureQueryLod(s2DArray, c2);
+    lod  += textureQueryLod(s2DArray, f16c2);
+    lod  += textureQueryLod(sCubeArray, c3);
+    lod  += textureQueryLod(sCubeArray, f16c3);
+    lod  += textureQueryLod(s1DShadow, c1);
+    lod  += textureQueryLod(s1DShadow, f16c1);
+    lod  += textureQueryLod(s2DShadow, c2);
+    lod  += textureQueryLod(s2DShadow, f16c2);
+    lod  += textureQueryLod(sCubeArrayShadow, c3);
+    lod  += textureQueryLod(sCubeArrayShadow, f16c3);
+    lod  += textureQueryLod(s1DArrayShadow, c1);
+    lod  += textureQueryLod(s1DArrayShadow, f16c1);
+    lod  += textureQueryLod(s2DArrayShadow, c2);
+    lod  += textureQueryLod(s2DArrayShadow, f16c2);
+    lod  += textureQueryLod(sCubeArrayShadow, c3);
+    lod  += textureQueryLod(sCubeArrayShadow, f16c3);
+
+    return lod;
+}
+
+int testTextureQueryLevels()
+{
+    int levels = 0;
+
+    levels  += textureQueryLevels(s1D);
+    levels  += textureQueryLevels(s2D);
+    levels  += textureQueryLevels(s3D);
+    levels  += textureQueryLevels(sCube);
+    levels  += textureQueryLevels(s1DShadow);
+    levels  += textureQueryLevels(s2DShadow);
+    levels  += textureQueryLevels(sCubeShadow);
+    levels  += textureQueryLevels(sCubeArray);
+    levels  += textureQueryLevels(sCubeArrayShadow);
+    levels  += textureQueryLevels(s1DArray);
+    levels  += textureQueryLevels(s2DArray);
+    levels  += textureQueryLevels(s1DArrayShadow);
+    levels  += textureQueryLevels(s2DArrayShadow);
+
+    return levels;
+}
+
+int testTextureSamples()
+{
+    int samples = 0;
+
+    samples += textureSamples(s2DMS);
+    samples += textureSamples(s2DMSArray);
+
+    return samples;
+}
+
+f16vec4 testImageLoad()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel += imageLoad(i1D, int(c1));
+    texel += imageLoad(i2D, ivec2(c2));
+    texel += imageLoad(i3D, ivec3(c3));
+    texel += imageLoad(i2DRect, ivec2(c2));
+    texel += imageLoad(iCube, ivec3(c3));
+    texel += imageLoad(iBuffer, int(c1));
+    texel += imageLoad(i1DArray, ivec2(c2));
+    texel += imageLoad(i2DArray, ivec3(c3));
+    texel += imageLoad(iCubeArray, ivec3(c3));
+    texel += imageLoad(i2DMS, ivec2(c2), 1);
+    texel += imageLoad(i2DMSArray, ivec3(c3), 1);
+
+    return texel;
+}
+
+void testImageStore(f16vec4 data)
+{
+    imageStore(i1D, int(c1), data);
+    imageStore(i2D, ivec2(c2), data);
+    imageStore(i3D, ivec3(c3), data);
+    imageStore(i2DRect, ivec2(c2), data);
+    imageStore(iCube, ivec3(c3), data);
+    imageStore(iBuffer, int(c1), data);
+    imageStore(i1DArray, ivec2(c2), data);
+    imageStore(i2DArray, ivec3(c3), data);
+    imageStore(iCubeArray, ivec3(c3), data);
+    imageStore(i2DMS, ivec2(c2), 1, data);
+    imageStore(i2DMSArray, ivec3(c3), 1, data);
+}
+
+f16vec4 testSparseTexture()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureARB(s2D, c2, texel);
+    sparseTextureARB(s2D, f16c2, texel, f16bias);
+    sparseTextureARB(s3D, c3, texel);
+    sparseTextureARB(s3D, f16c3, texel, f16bias);
+    sparseTextureARB(sCube, c3, texel);
+    sparseTextureARB(sCube, f16c3, texel, f16bias);
+    sparseTextureARB(s2DShadow, c3, texel.x);
+    sparseTextureARB(s2DShadow, f16c2, compare, texel.x, f16bias);
+    sparseTextureARB(sCubeShadow, c4, texel.x);
+    sparseTextureARB(sCubeShadow, f16c3, compare, texel.x, f16bias);
+    sparseTextureARB(s2DArray, c3, texel);
+    sparseTextureARB(s2DArray, f16c3, texel, f16bias);
+    sparseTextureARB(sCubeArray, c4, texel);
+    sparseTextureARB(sCubeArray, f16c4, texel, f16bias);
+    sparseTextureARB(s2DArrayShadow, c4, texel.x);
+    sparseTextureARB(s2DArrayShadow, f16c3, compare, texel.x);
+    sparseTextureARB(s2DRect, c2, texel);
+    sparseTextureARB(s2DRect, f16c2, texel);
+    sparseTextureARB(s2DRectShadow, c3, texel.x);
+    sparseTextureARB(s2DRectShadow, f16c2, compare, texel.x);
+    sparseTextureARB(sCubeArrayShadow, c4, compare, texel.x);
+    sparseTextureARB(sCubeArrayShadow, f16c4, compare, texel.x);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureLod()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureLodARB(s2D, c2, lod, texel);
+    sparseTextureLodARB(s2D, f16c2, f16lod, texel);
+    sparseTextureLodARB(s3D, c3, lod, texel);
+    sparseTextureLodARB(s3D, f16c3, f16lod, texel);
+    sparseTextureLodARB(sCube, c3, lod, texel);
+    sparseTextureLodARB(sCube, f16c3, f16lod, texel);
+    sparseTextureLodARB(s2DShadow, c3, lod, texel.x);
+    sparseTextureLodARB(s2DShadow, f16c2, compare, f16lod, texel.x);
+    sparseTextureLodARB(s2DArray, c3, lod, texel);
+    sparseTextureLodARB(s2DArray, f16c3, f16lod, texel);
+    sparseTextureLodARB(sCubeArray, c4, lod, texel);
+    sparseTextureLodARB(sCubeArray, f16c4, f16lod, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureOffsetARB(s2D, c2, offset2, texel);
+    sparseTextureOffsetARB(s2D, f16c2, offset2, texel, f16bias);
+    sparseTextureOffsetARB(s3D, c3, offset3, texel);
+    sparseTextureOffsetARB(s3D, f16c3, offset3, texel, f16bias);
+    sparseTextureOffsetARB(s2DRect, c2, offset2, texel);
+    sparseTextureOffsetARB(s2DRect, f16c2, offset2, texel);
+    sparseTextureOffsetARB(s2DRectShadow, c3, offset2, texel.x);
+    sparseTextureOffsetARB(s2DRectShadow, f16c2, compare, offset2, texel.x);
+    sparseTextureOffsetARB(s2DShadow, c3, offset2, texel.x);
+    sparseTextureOffsetARB(s2DShadow, f16c2, compare, offset2, texel.x, f16bias);
+    sparseTextureOffsetARB(s2DArray, c3, offset2, texel);
+    sparseTextureOffsetARB(s2DArray, f16c3, offset2, texel, f16bias);
+    sparseTextureOffsetARB(s2DArrayShadow, c4, offset2, texel.x);
+    sparseTextureOffsetARB(s2DArrayShadow, f16c3, compare, offset2, texel.x);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureLodOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureLodOffsetARB(s2D, c2, lod, offset2, texel);
+    sparseTextureLodOffsetARB(s2D, f16c2, f16lod, offset2, texel);
+    sparseTextureLodOffsetARB(s3D, c3, lod, offset3, texel);
+    sparseTextureLodOffsetARB(s3D, f16c3, f16lod, offset3, texel);
+    sparseTextureLodOffsetARB(s2DShadow, c3, lod, offset2, texel.x);
+    sparseTextureLodOffsetARB(s2DShadow, f16c2, compare, f16lod, offset2, texel.x);
+    sparseTextureLodOffsetARB(s2DArray, c3, lod, offset2, texel);
+    sparseTextureLodOffsetARB(s2DArray, f16c3, f16lod, offset2, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGrad()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGradARB(s2D, c2, dPdxy2, dPdxy2, texel);
+    sparseTextureGradARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, texel);
+    sparseTextureGradARB(s3D, c3, dPdxy3, dPdxy3, texel);
+    sparseTextureGradARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, texel);
+    sparseTextureGradARB(sCube, c3, dPdxy3, dPdxy3, texel);
+    sparseTextureGradARB(sCube, f16c3, f16dPdxy3, f16dPdxy3, texel);
+    sparseTextureGradARB(s2DRect, c2, dPdxy2, dPdxy2, texel);
+    sparseTextureGradARB(s2DRect, f16c2, f16dPdxy2, f16dPdxy2, texel);
+    sparseTextureGradARB(s2DRectShadow, c3, dPdxy2, dPdxy2, texel.x);
+    sparseTextureGradARB(s2DRectShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, texel.x);
+    sparseTextureGradARB(s2DShadow, c3, dPdxy2, dPdxy2, texel.x);
+    sparseTextureGradARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, texel.x);
+    sparseTextureGradARB(sCubeShadow, c4, dPdxy3, dPdxy3, texel.x);
+    sparseTextureGradARB(sCubeShadow, f16c3, compare, f16dPdxy3, f16dPdxy3, texel.x);
+    sparseTextureGradARB(s2DArray, c3, dPdxy2, dPdxy2, texel);
+    sparseTextureGradARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, texel);
+    sparseTextureGradARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, texel.x);
+    sparseTextureGradARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, texel.x);
+    sparseTextureGradARB(sCubeArray, c4, dPdxy3, dPdxy3, texel);
+    sparseTextureGradARB(sCubeArray, f16c4, f16dPdxy3, f16dPdxy3, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGradOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGradOffsetARB(s2D, c2, dPdxy2, dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s3D, c3, dPdxy3, dPdxy3, offset3, texel);
+    sparseTextureGradOffsetARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, offset3, texel);
+    sparseTextureGradOffsetARB(s2DRect, c2, dPdxy2, dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s2DRect, f16c2, f16dPdxy2, f16dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s2DRectShadow, c3, dPdxy2, dPdxy2, offset2, texel.x);
+    sparseTextureGradOffsetARB(s2DRectShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2, texel.x);
+    sparseTextureGradOffsetARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, texel.x);
+    sparseTextureGradOffsetARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2, texel.x);
+    sparseTextureGradOffsetARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, offset2, texel);
+    sparseTextureGradOffsetARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, texel.x);
+    sparseTextureGradOffsetARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2, texel.x);
+
+    return texel;
+}
+
+f16vec4 testSparseTexelFetch()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTexelFetchARB(s2D, ivec2(c2), int(lod), texel);
+    sparseTexelFetchARB(s3D, ivec3(c3), int(lod), texel);
+    sparseTexelFetchARB(s2DRect, ivec2(c2), texel);
+    sparseTexelFetchARB(s2DArray, ivec3(c3), int(lod), texel);
+    sparseTexelFetchARB(s2DMS, ivec2(c2), 1, texel);
+    sparseTexelFetchARB(s2DMSArray, ivec3(c3), 2, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTexelFetchOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTexelFetchOffsetARB(s2D, ivec2(c2), int(lod), offset2, texel);
+    sparseTexelFetchOffsetARB(s3D, ivec3(c3), int(lod), offset3, texel);
+    sparseTexelFetchOffsetARB(s2DRect, ivec2(c2), offset2, texel);
+    sparseTexelFetchOffsetARB(s2DArray, ivec3(c3), int(lod), offset2, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGather()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherARB(s2D, c2, texel, 0);
+    sparseTextureGatherARB(s2D, f16c2, texel, 0, f16bias);
+    sparseTextureGatherARB(s2DArray, c3, texel, 0);
+    sparseTextureGatherARB(s2DArray, f16c3, texel, 0, f16bias);
+    sparseTextureGatherARB(sCube, c3, texel, 0);
+    sparseTextureGatherARB(sCube, f16c3, texel, 0, f16bias);
+    sparseTextureGatherARB(sCubeArray, c4, texel, 0);
+    sparseTextureGatherARB(sCubeArray, f16c4, texel, 0, f16bias);
+    sparseTextureGatherARB(s2DRect, c2, texel, 0);
+    sparseTextureGatherARB(s2DRect, f16c2, texel, 0);
+    sparseTextureGatherARB(s2DShadow, c2, compare, texel);
+    sparseTextureGatherARB(s2DShadow, f16c2, compare, texel);
+    sparseTextureGatherARB(s2DArrayShadow, c3, compare, texel);
+    sparseTextureGatherARB(s2DArrayShadow, f16c3, compare, texel);
+    sparseTextureGatherARB(sCubeShadow, c3, compare, texel);
+    sparseTextureGatherARB(sCubeShadow, f16c3, compare, texel);
+    sparseTextureGatherARB(sCubeArrayShadow, c4, compare, texel);
+    sparseTextureGatherARB(sCubeArrayShadow, f16c4, compare, texel);
+    sparseTextureGatherARB(s2DRectShadow, c2, compare, texel);
+    sparseTextureGatherARB(s2DRectShadow, f16c2, compare, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGatherOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherOffsetARB(s2D, c2, offset2, texel, 0);
+    sparseTextureGatherOffsetARB(s2D, f16c2, offset2, texel, 0, f16bias);
+    sparseTextureGatherOffsetARB(s2DArray, c3, offset2, texel, 0);
+    sparseTextureGatherOffsetARB(s2DArray, f16c3, offset2, texel, 0, f16bias);
+    sparseTextureGatherOffsetARB(s2DRect, c2, offset2, texel, 0);
+    sparseTextureGatherOffsetARB(s2DRect, f16c2, offset2, texel, 0);
+    sparseTextureGatherOffsetARB(s2DShadow, c2, compare, offset2, texel);
+    sparseTextureGatherOffsetARB(s2DShadow, f16c2, compare, offset2, texel);
+    sparseTextureGatherOffsetARB(s2DArrayShadow, c3, compare, offset2, texel);
+    sparseTextureGatherOffsetARB(s2DArrayShadow, f16c3, compare, offset2, texel);
+    sparseTextureGatherOffsetARB(s2DRectShadow, c2, compare, offset2, texel);
+    sparseTextureGatherOffsetARB(s2DRectShadow, f16c2, compare, offset2, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGatherOffsets()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherOffsetsARB(s2D, c2, offsets, texel, 0);
+    sparseTextureGatherOffsetsARB(s2D, f16c2, offsets, texel, 0, f16bias);
+    sparseTextureGatherOffsetsARB(s2DArray, c3, offsets, texel, 0);
+    sparseTextureGatherOffsetsARB(s2DArray, f16c3, offsets, texel, 0, f16bias);
+    sparseTextureGatherOffsetsARB(s2DRect, c2, offsets, texel, 0);
+    sparseTextureGatherOffsetsARB(s2DRect, f16c2, offsets, texel, 0);
+    sparseTextureGatherOffsetsARB(s2DShadow, c2, compare, offsets, texel);
+    sparseTextureGatherOffsetsARB(s2DShadow, f16c2, compare, offsets, texel);
+    sparseTextureGatherOffsetsARB(s2DArrayShadow, c3, compare, offsets, texel);
+    sparseTextureGatherOffsetsARB(s2DArrayShadow, f16c3, compare, offsets, texel);
+    sparseTextureGatherOffsetsARB(s2DRectShadow, c2, compare, offsets, texel);
+    sparseTextureGatherOffsetsARB(s2DRectShadow, f16c2, compare, offsets, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGatherLod()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherLodAMD(s2D, c2, lod, texel, 0);
+    sparseTextureGatherLodAMD(s2D, f16c2, f16lod, texel, 0);
+    sparseTextureGatherLodAMD(s2DArray, c3, lod, texel, 0);
+    sparseTextureGatherLodAMD(s2DArray, f16c3, f16lod, texel, 0);
+    sparseTextureGatherLodAMD(sCube, c3, lod, texel, 0);
+    sparseTextureGatherLodAMD(sCube, f16c3, f16lod, texel, 0);
+    sparseTextureGatherLodAMD(sCubeArray, c4, lod, texel, 0);
+    sparseTextureGatherLodAMD(sCubeArray, f16c4, f16lod, texel, 0);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGatherLodOffset()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherLodOffsetAMD(s2D, c2, lod, offset2, texel, 0);
+    sparseTextureGatherLodOffsetAMD(s2D, f16c2, f16lod, offset2, texel, 0);
+    sparseTextureGatherLodOffsetAMD(s2DArray, c3, lod, offset2, texel, 0);
+    sparseTextureGatherLodOffsetAMD(s2DArray, f16c3, f16lod, offset2, texel, 0);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGatherLodOffsets()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGatherLodOffsetsAMD(s2D, c2, lod, offsets, texel, 0);
+    sparseTextureGatherLodOffsetsAMD(s2D, f16c2, f16lod, offsets, texel, 0);
+    sparseTextureGatherLodOffsetsAMD(s2DArray, c3, lod, offsets, texel, 0);
+    sparseTextureGatherLodOffsetsAMD(s2DArray, f16c3, f16lod, offsets, texel, 0);
+
+    return texel;
+}
+
+f16vec4 testSparseImageLoad()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseImageLoadARB(i2D, ivec2(c2), texel);
+    sparseImageLoadARB(i3D, ivec3(c3), texel);
+    sparseImageLoadARB(i2DRect, ivec2(c2), texel);
+    sparseImageLoadARB(iCube, ivec3(c3), texel);
+    sparseImageLoadARB(i2DArray, ivec3(c3), texel);
+    sparseImageLoadARB(iCubeArray, ivec3(c3), texel);
+    sparseImageLoadARB(i2DMS, ivec2(c2), 1, texel);
+    sparseImageLoadARB(i2DMSArray, ivec3(c3), 2, texel);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureClampARB(s2D, c2, lodClamp, texel);
+    sparseTextureClampARB(s2D, f16c2, f16lodClamp, texel, f16bias);
+    sparseTextureClampARB(s3D, c3, lodClamp, texel);
+    sparseTextureClampARB(s3D, f16c3, f16lodClamp, texel, f16bias);
+    sparseTextureClampARB(sCube, c3, lodClamp, texel);
+    sparseTextureClampARB(sCube, f16c3, f16lodClamp, texel, f16bias);
+    sparseTextureClampARB(s2DShadow, c3, lodClamp, texel.x);
+    sparseTextureClampARB(s2DShadow, f16c2, compare, f16lodClamp, texel.x, f16bias);
+    sparseTextureClampARB(sCubeShadow, c4, lodClamp, texel.x);
+    sparseTextureClampARB(sCubeShadow, f16c3, compare, f16lodClamp, texel.x, f16bias);
+    sparseTextureClampARB(s2DArray, c3, lodClamp, texel);
+    sparseTextureClampARB(s2DArray, f16c3, f16lodClamp, texel, f16bias);
+    sparseTextureClampARB(sCubeArray, c4, lodClamp, texel);
+    sparseTextureClampARB(sCubeArray, f16c4, f16lodClamp, texel, f16bias);
+    sparseTextureClampARB(s2DArrayShadow, c4, lodClamp, texel.x);
+    sparseTextureClampARB(s2DArrayShadow, f16c3, compare, f16lodClamp, texel.x);
+    sparseTextureClampARB(sCubeArrayShadow, c4, compare, lodClamp, texel.x);
+    sparseTextureClampARB(sCubeArrayShadow, f16c4, compare, f16lodClamp, texel.x);
+
+    return texel;
+}
+
+f16vec4 testTextureClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureClampARB(s1D, c1, lodClamp);
+    texel   += textureClampARB(s1D, f16c1, f16lodClamp, f16bias);
+    texel   += textureClampARB(s2D, c2, lodClamp);
+    texel   += textureClampARB(s2D, f16c2, f16lodClamp, f16bias);
+    texel   += textureClampARB(s3D, c3, lodClamp);
+    texel   += textureClampARB(s3D, f16c3, f16lodClamp, f16bias);
+    texel   += textureClampARB(sCube, c3, lodClamp);
+    texel   += textureClampARB(sCube, f16c3, f16lodClamp, f16bias);
+    texel.x += textureClampARB(s1DShadow, c3, lodClamp);
+    texel.x += textureClampARB(s1DShadow, f16c2, compare, f16lodClamp, f16bias);
+    texel.x += textureClampARB(s2DShadow, c3, lodClamp);
+    texel.x += textureClampARB(s2DShadow, f16c2, compare, f16lodClamp, f16bias);
+    texel.x += textureClampARB(sCubeShadow, c4, lodClamp);
+    texel.x += textureClampARB(sCubeShadow, f16c3, compare, f16lodClamp, f16bias);
+    texel   += textureClampARB(s1DArray, c2, lodClamp);
+    texel   += textureClampARB(s1DArray, f16c2, f16lodClamp, f16bias);
+    texel   += textureClampARB(s2DArray, c3, lodClamp);
+    texel   += textureClampARB(s2DArray, f16c3, f16lodClamp, f16bias);
+    texel   += textureClampARB(sCubeArray, c4, lodClamp);
+    texel   += textureClampARB(sCubeArray, f16c4, f16lodClamp, f16bias);
+    texel.x += textureClampARB(s1DArrayShadow, c3, lodClamp);
+    texel.x += textureClampARB(s1DArrayShadow, f16c2, compare, f16lodClamp, f16bias);
+    texel.x += textureClampARB(s2DArrayShadow, c4, lodClamp);
+    texel.x += textureClampARB(s2DArrayShadow, f16c3, compare, f16lodClamp);
+    texel.x += textureClampARB(sCubeArrayShadow, c4, compare, lodClamp);
+    texel.x += textureClampARB(sCubeArrayShadow, f16c4, compare, f16lodClamp);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureOffsetClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureOffsetClampARB(s2D, c2, offset2, lodClamp, texel);
+    sparseTextureOffsetClampARB(s2D, f16c2, offset2, f16lodClamp, texel, f16bias);
+    sparseTextureOffsetClampARB(s3D, c3, offset3, lodClamp, texel);
+    sparseTextureOffsetClampARB(s3D, f16c3, offset3, f16lodClamp, texel, f16bias);
+    sparseTextureOffsetClampARB(s2DShadow, c3, offset2, lodClamp, texel.x);
+    sparseTextureOffsetClampARB(s2DShadow, f16c2, compare, offset2, f16lodClamp, texel.x, f16bias);
+    sparseTextureOffsetClampARB(s2DArray, c3, offset2, lodClamp, texel);
+    sparseTextureOffsetClampARB(s2DArray, f16c3, offset2, f16lodClamp, texel, f16bias);
+    sparseTextureOffsetClampARB(s2DArrayShadow, c4, offset2, lodClamp, texel.x);
+    sparseTextureOffsetClampARB(s2DArrayShadow, f16c3, compare, offset2, f16lodClamp, texel.x);
+
+    return texel;
+}
+
+f16vec4 testTextureOffsetClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureOffsetClampARB(s1D, c1, offset1, lodClamp);
+    texel   += textureOffsetClampARB(s1D, f16c1, offset1, f16lodClamp, f16bias);
+    texel   += textureOffsetClampARB(s2D, c2, offset2, lodClamp);
+    texel   += textureOffsetClampARB(s2D, f16c2, offset2, f16lodClamp, f16bias);
+    texel   += textureOffsetClampARB(s3D, c3, offset3, lodClamp);
+    texel   += textureOffsetClampARB(s3D, f16c3, offset3, f16lodClamp, f16bias);
+    texel.x += textureOffsetClampARB(s1DShadow, c3, offset1, lodClamp);
+    texel.x += textureOffsetClampARB(s1DShadow, f16c2, compare, offset1, f16lodClamp, f16bias);
+    texel.x += textureOffsetClampARB(s2DShadow, c3, offset2, lodClamp);
+    texel.x += textureOffsetClampARB(s2DShadow, f16c2, compare, offset2, f16lodClamp, f16bias);
+    texel   += textureOffsetClampARB(s1DArray, c2, offset1, lodClamp);
+    texel   += textureOffsetClampARB(s1DArray, f16c2, offset1, f16lodClamp, f16bias);
+    texel   += textureOffsetClampARB(s2DArray, c3, offset2, lodClamp);
+    texel   += textureOffsetClampARB(s2DArray, f16c3, offset2, f16lodClamp, f16bias);
+    texel.x += textureOffsetClampARB(s1DArrayShadow, c3, offset1, lodClamp);
+    texel.x += textureOffsetClampARB(s1DArrayShadow, f16c2, compare, offset1, f16lodClamp, f16bias);
+    texel.x += textureOffsetClampARB(s2DArrayShadow, c4, offset2, lodClamp);
+    texel.x += textureOffsetClampARB(s2DArrayShadow, f16c3, compare, offset2, f16lodClamp);
+    
+    return texel;
+}
+
+f16vec4 testSparseTextureGradClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGradClampARB(s2D, c2, dPdxy2, dPdxy2, lodClamp, texel);
+    sparseTextureGradClampARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, f16lodClamp, texel);
+    sparseTextureGradClampARB(s3D, c3, dPdxy3, dPdxy3, lodClamp, texel);
+    sparseTextureGradClampARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, f16lodClamp, texel);
+    sparseTextureGradClampARB(sCube, c3, dPdxy3, dPdxy3, lodClamp, texel);
+    sparseTextureGradClampARB(sCube, f16c3, f16dPdxy3, f16dPdxy3, f16lodClamp, texel);
+    sparseTextureGradClampARB(s2DShadow, c3, dPdxy2, dPdxy2, lodClamp, texel.x);
+    sparseTextureGradClampARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, f16lodClamp, texel.x);
+    sparseTextureGradClampARB(sCubeShadow, c4, dPdxy3, dPdxy3, lodClamp, texel.x);
+    sparseTextureGradClampARB(sCubeShadow, f16c3, compare, f16dPdxy3, f16dPdxy3, f16lodClamp, texel.x);
+    sparseTextureGradClampARB(s2DArray, c3, dPdxy2, dPdxy2, lodClamp, texel);
+    sparseTextureGradClampARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, f16lodClamp, texel);
+    sparseTextureGradClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, lodClamp, texel.x);
+    sparseTextureGradClampARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, f16lodClamp, texel.x);
+    sparseTextureGradClampARB(sCubeArray, c4, dPdxy3, dPdxy3, lodClamp, texel);
+    sparseTextureGradClampARB(sCubeArray, f16c4, f16dPdxy3, f16dPdxy3, f16lodClamp, texel);
+
+    return texel;
+}
+
+f16vec4 testTextureGradClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGradClampARB(s1D, c1, dPdxy1, dPdxy1, lodClamp);
+    texel   += textureGradClampARB(s1D, f16c1, f16dPdxy1, f16dPdxy1, f16lodClamp);
+    texel   += textureGradClampARB(s2D, c2, dPdxy2, dPdxy2, lodClamp);
+    texel   += textureGradClampARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, f16lodClamp);
+    texel   += textureGradClampARB(s3D, c3, dPdxy3, dPdxy3, lodClamp);
+    texel   += textureGradClampARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, f16lodClamp);
+    texel   += textureGradClampARB(sCube, c3, dPdxy3, dPdxy3, lodClamp);
+    texel   += textureGradClampARB(sCube, f16c3, f16dPdxy3, f16dPdxy3, f16lodClamp);
+    texel.x += textureGradClampARB(s1DShadow, c3, dPdxy1, dPdxy1, lodClamp);
+    texel.x += textureGradClampARB(s1DShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, f16lodClamp);
+    texel.x += textureGradClampARB(s2DShadow, c3, dPdxy2, dPdxy2, lodClamp);
+    texel.x += textureGradClampARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, f16lodClamp);
+    texel.x += textureGradClampARB(sCubeShadow, c4, dPdxy3, dPdxy3, lodClamp);
+    texel.x += textureGradClampARB(sCubeShadow, f16c3, compare, f16dPdxy3, f16dPdxy3, f16lodClamp);
+    texel   += textureGradClampARB(s1DArray, c2, dPdxy1, dPdxy1, lodClamp);
+    texel   += textureGradClampARB(s1DArray, f16c2, f16dPdxy1, f16dPdxy1, f16lodClamp);
+    texel   += textureGradClampARB(s2DArray, c3, dPdxy2, dPdxy2, lodClamp);
+    texel   += textureGradClampARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, f16lodClamp);
+    texel.x += textureGradClampARB(s1DArrayShadow, c3, dPdxy1, dPdxy1, lodClamp);
+    texel.x += textureGradClampARB(s1DArrayShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, f16lodClamp);
+    texel.x += textureGradClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, lodClamp);
+    texel.x += textureGradClampARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, f16lodClamp);
+    texel   += textureGradClampARB(sCubeArray, c4, dPdxy3, dPdxy3, lodClamp);
+    texel   += textureGradClampARB(sCubeArray, f16c4, f16dPdxy3, f16dPdxy3, f16lodClamp);
+
+    return texel;
+}
+
+f16vec4 testSparseTextureGradOffsetClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    sparseTextureGradOffsetClampARB(s2D, c2, dPdxy2, dPdxy2, offset2, lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s3D, c3, dPdxy3, dPdxy3, offset3, lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, offset3, f16lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, lodClamp, texel.x);
+    sparseTextureGradOffsetClampARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp, texel.x);
+    sparseTextureGradOffsetClampARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp, texel);
+    sparseTextureGradOffsetClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, lodClamp, texel.x);
+    sparseTextureGradOffsetClampARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp, texel.x);
+
+    return texel;
+}
+
+f16vec4 testTextureGradOffsetClamp()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += textureGradOffsetClampARB(s1D, c1, dPdxy1, dPdxy1, offset1, lodClamp);
+    texel   += textureGradOffsetClampARB(s1D, f16c1, f16dPdxy1, f16dPdxy1, offset1, f16lodClamp);
+    texel   += textureGradOffsetClampARB(s2D, c2, dPdxy2, dPdxy2, offset2, lodClamp);
+    texel   += textureGradOffsetClampARB(s2D, f16c2, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp);
+    texel   += textureGradOffsetClampARB(s3D, c3, dPdxy3, dPdxy3, offset3, lodClamp);
+    texel   += textureGradOffsetClampARB(s3D, f16c3, f16dPdxy3, f16dPdxy3, offset3, f16lodClamp);
+    texel.x += textureGradOffsetClampARB(s1DShadow, c3, dPdxy1, dPdxy1, offset1, lodClamp);
+    texel.x += textureGradOffsetClampARB(s1DShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, offset1, f16lodClamp);
+    texel.x += textureGradOffsetClampARB(s2DShadow, c3, dPdxy2, dPdxy2, offset2, lodClamp);
+    texel.x += textureGradOffsetClampARB(s2DShadow, f16c2, compare, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp);
+    texel   += textureGradOffsetClampARB(s1DArray, c2, dPdxy1, dPdxy1, offset1, lodClamp);
+    texel   += textureGradOffsetClampARB(s1DArray, f16c2, f16dPdxy1, f16dPdxy1, offset1, f16lodClamp);
+    texel   += textureGradOffsetClampARB(s2DArray, c3, dPdxy2, dPdxy2, offset2, lodClamp);
+    texel   += textureGradOffsetClampARB(s2DArray, f16c3, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp);
+    texel.x += textureGradOffsetClampARB(s1DArrayShadow, c3, dPdxy1, dPdxy1, offset1, lodClamp);
+    texel.x += textureGradOffsetClampARB(s1DArrayShadow, f16c2, compare, f16dPdxy1, f16dPdxy1, offset1, f16lodClamp);
+    texel.x += textureGradOffsetClampARB(s2DArrayShadow, c4, dPdxy2, dPdxy2, offset2, lodClamp);
+    texel.x += textureGradOffsetClampARB(s2DArrayShadow, f16c3, compare, f16dPdxy2, f16dPdxy2, offset2, f16lodClamp);
+
+    return texel;
+}
+
+f16vec4 testCombinedTextureSampler()
+{
+    f16vec4 texel = f16vec4(0.0hf);
+
+    texel   += texture(f16sampler1D(t1D, s), c1);
+    texel   += texture(f16sampler1D(t1D, s), f16c1, f16bias);
+    texel   += texture(f16sampler2D(t2D, s), c2);
+    texel   += texture(f16sampler2D(t2D, s), f16c2, f16bias);
+    texel   += texture(f16sampler3D(t3D, s), c3);
+    texel   += texture(f16sampler3D(t3D, s), f16c3, f16bias);
+    texel   += texture(f16samplerCube(tCube, s), c3);
+    texel   += texture(f16samplerCube(tCube, s), f16c3, f16bias);
+    texel.x += texture(f16sampler1DShadow(t1D, sShadow), c3);
+    texel.x += texture(f16sampler1DShadow(t1D, sShadow), f16c2, compare, f16bias);
+    texel.x += texture(f16sampler2DShadow(t2D, sShadow), c3);
+    texel.x += texture(f16sampler2DShadow(t2D, sShadow), f16c2, compare, f16bias);
+    texel.x += texture(f16samplerCubeShadow(tCube, sShadow), c4);
+    texel.x += texture(f16samplerCubeShadow(tCube, sShadow), f16c3, compare, f16bias);
+    texel   += texture(f16sampler1DArray(t1DArray, s), c2);
+    texel   += texture(f16sampler1DArray(t1DArray, s), f16c2, f16bias);
+    texel   += texture(f16sampler2DArray(t2DArray, s), c3);
+    texel   += texture(f16sampler2DArray(t2DArray, s), f16c3, f16bias);
+    texel   += texture(f16samplerCubeArray(tCubeArray, s), c4);
+    texel   += texture(f16samplerCubeArray(tCubeArray, s), f16c4, f16bias);
+    texel.x += texture(f16sampler1DArrayShadow(t1DArray, sShadow), c3);
+    texel.x += texture(f16sampler1DArrayShadow(t1DArray, sShadow), f16c2, compare, f16bias);
+    texel.x += texture(f16sampler2DArrayShadow(t2DArray, sShadow), c4);
+    texel.x += texture(f16sampler2DArrayShadow(t2DArray, sShadow), f16c3, compare);
+    texel   += texture(f16sampler2DRect(t2DRect, s), c2);
+    texel   += texture(f16sampler2DRect(t2DRect, s), f16c2);
+    texel.x += texture(f16sampler2DRectShadow(t2DRect, sShadow), c3);
+    texel.x += texture(f16sampler2DRectShadow(t2DRect, sShadow), f16c2, compare);
+    texel.x += texture(f16samplerCubeArrayShadow(tCubeArray, sShadow), c4, compare);
+    texel.x += texture(f16samplerCubeArrayShadow(tCubeArray, sShadow), f16c4, compare);
+
+    return texel;
+}
+
+f16vec4 testSubpassLoad()
+{
+    return subpassLoad(subpass) + subpassLoad(subpassMS, 2);
+}
+
+void main()
+{
+    f16vec4 result = f16vec4(0.0hf);
+
+    result  += testTexture();
+    result  += testTextureProj();
+    result  += testTextureLod();
+    result  += testTextureOffset();
+    result  += testTextureLodOffset();
+    result  += testTextureProjLodOffset();
+    result  += testTexelFetch();
+    result  += testTexelFetchOffset();
+    result  += testTextureGrad();
+    result  += testTextureGradOffset();
+    result  += testTextureProjGrad();
+    result  += testTextureProjGradoffset();
+    result  += testTextureGather();
+    result  += testTextureGatherOffset();
+    result  += testTextureGatherOffsets();
+    result  += testTextureGatherLod();
+    result  += testTextureGatherLodOffset();
+    result  += testTextureGatherLodOffsets();
+
+    result    += f16vec4(testTextureSize());
+    result.xy += f16vec2(testTextureQueryLod());
+    result.x  += float16_t(testTextureQueryLevels());
+    result.x  += float16_t(testTextureSamples());
+
+    result  += testImageLoad();
+    testImageStore(result);
+
+    result += testSparseTexture();
+    result += testSparseTextureLod();
+    result += testSparseTextureOffset();
+    result += testSparseTextureLodOffset();
+    result += testSparseTextureGrad();
+    result += testSparseTextureGradOffset();
+    result += testSparseTexelFetch();
+    result += testSparseTexelFetchOffset();
+    result += testSparseTextureGather();
+    result += testSparseTextureGatherOffset();
+    result += testSparseTextureGatherOffsets();
+    result += testSparseTextureGatherLod();
+    result += testSparseTextureGatherLodOffset();
+    result += testSparseTextureGatherLodOffsets();
+
+    result += testSparseImageLoad();
+
+    result += testSparseTextureClamp();
+    result += testTextureClamp();
+    result += testSparseTextureOffsetClamp();
+    result += testTextureOffsetClamp();
+    result += testSparseTextureGrad();
+    result += testTextureGrad();
+    result += testSparseTextureGradOffsetClamp();
+    result += testTextureGradOffsetClamp();
+
+    result += testCombinedTextureSampler();
+    result += testSubpassLoad();
+
+    fragColor = result;
+}

+ 3 - 0
glslang/Include/Types.h

@@ -205,6 +205,9 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
 
         switch (type) {
         case EbtFloat:               break;
+#ifdef AMD_EXTENSIONS
+        case EbtFloat16: s.append("f16"); break;
+#endif
         case EbtInt:  s.append("i"); break;
         case EbtUint: s.append("u"); break;
         default:  break;  // some compilers want this

+ 420 - 264
glslang/MachineIndependent/Initialize.cpp

@@ -82,7 +82,10 @@ TBuiltIns::TBuiltIns()
 {
     // Set up textual representations for making all the permutations
     // of texturing/imaging functions.
-    prefixes[EbtFloat] =  "";
+    prefixes[EbtFloat] = "";
+#ifdef AMD_EXTENSIONS
+    prefixes[EbtFloat16] = "f16";
+#endif
     prefixes[EbtInt]   = "i";
     prefixes[EbtUint]  = "u";
     postfixes[2] = "2";
@@ -4059,8 +4062,11 @@ void TBuiltIns::add2ndGenerationSamplingImaging(int version, EProfile profile, c
     // In this function proper, enumerate the types, then calls the next set of functions
     // to enumerate all the uses for that type.
     //
-
+#ifdef AMD_EXTENSIONS
+    TBasicType bTypes[4] = { EbtFloat, EbtFloat16, EbtInt, EbtUint };
+#else
     TBasicType bTypes[3] = { EbtFloat, EbtInt, EbtUint };
+#endif
     bool skipBuffer = (profile == EEsProfile && version < 310) || (profile != EEsProfile && version < 140);
     bool skipCubeArrayed = (profile == EEsProfile && version < 310) || (profile != EEsProfile && version < 130);
 
@@ -4100,12 +4106,20 @@ void TBuiltIns::add2ndGenerationSamplingImaging(int version, EProfile profile, c
                             continue;
                         if (ms && arrayed && profile == EEsProfile && version < 310)
                             continue;
+#ifdef AMD_EXTENSIONS
+                        for (int bType = 0; bType < 4; ++bType) { // float, float16, int, uint results
+
+                            if (shadow && bType > 1)
+                                continue;
 
+                            if (bTypes[bType] == EbtFloat16 && (profile == EEsProfile ||version < 450))
+                                continue;
+#else
                         for (int bType = 0; bType < 3; ++bType) { // float, int, uint results
 
                             if (shadow && bType > 0)
                                 continue;
-
+#endif
                             if (dim == EsdRect && version < 140 && bType > 0)
                                 continue;
 
@@ -4223,15 +4237,37 @@ void TBuiltIns::addQueryFunctions(TSampler sampler, const TString& typeName, int
     //
 
     if (profile != EEsProfile && version >= 400 && ! sampler.image && sampler.dim != EsdRect && ! sampler.ms && sampler.dim != EsdBuffer) {
-        stageBuiltins[EShLangFragment].append("vec2 textureQueryLod(");
-        stageBuiltins[EShLangFragment].append(typeName);
-        if (dimMap[sampler.dim] == 1)
-            stageBuiltins[EShLangFragment].append(", float");
-        else {
-            stageBuiltins[EShLangFragment].append(", vec");
-            stageBuiltins[EShLangFragment].append(postfixes[dimMap[sampler.dim]]);
+#ifdef AMD_EXTENSIONS
+        for (int f16TexAddr = 0; f16TexAddr < 2; ++f16TexAddr) {
+            if (f16TexAddr && sampler.type != EbtFloat16)
+                continue;
+#endif
+            stageBuiltins[EShLangFragment].append("vec2 textureQueryLod(");
+            stageBuiltins[EShLangFragment].append(typeName);
+            if (dimMap[sampler.dim] == 1)
+#ifdef AMD_EXTENSIONS
+                if (f16TexAddr)
+                    stageBuiltins[EShLangFragment].append(", float16_t");
+                else
+                    stageBuiltins[EShLangFragment].append(", float");
+#else
+                stageBuiltins[EShLangFragment].append(", float");
+#endif
+            else {
+#ifdef AMD_EXTENSIONS
+                if (f16TexAddr)
+                    stageBuiltins[EShLangFragment].append(", f16vec");
+                else
+                    stageBuiltins[EShLangFragment].append(", vec");
+#else
+                stageBuiltins[EShLangFragment].append(", vec");
+#endif
+                stageBuiltins[EShLangFragment].append(postfixes[dimMap[sampler.dim]]);
+            }
+            stageBuiltins[EShLangFragment].append(");\n");
+#ifdef AMD_EXTENSIONS
         }
-        stageBuiltins[EShLangFragment].append(");\n");
+#endif
     }
 
     //
@@ -4421,7 +4457,7 @@ void TBuiltIns::addSamplingFunctions(TSampler sampler, const TString& typeName,
 
                 if (bias && (lod || sampler.ms))
                     continue;
-                if (bias && sampler.dim == Esd2D && sampler.shadow && sampler.arrayed)
+                if (bias && (sampler.dim == Esd2D || sampler.dim == EsdCube) && sampler.shadow && sampler.arrayed)
                     continue;
                 if (bias && (sampler.dim == EsdRect || sampler.dim == EsdBuffer))
                     continue;
@@ -4470,149 +4506,237 @@ void TBuiltIns::addSamplingFunctions(TSampler sampler, const TString& typeName,
                                     continue;
                                 if (extraProj && (sampler.dim == Esd3D || sampler.shadow))
                                     continue;
+#ifdef AMD_EXTENSIONS
+                                for (int f16TexAddr = 0; f16TexAddr <= 1; ++f16TexAddr) { // loop over 16-bit floating-point texel addressing
 
-                                for (int lodClamp = 0; lodClamp <= 1 ;++lodClamp) { // loop over "bool" lod clamp
-
-                                    if (lodClamp && (profile == EEsProfile || version < 450))
+                                    if (f16TexAddr && sampler.type != EbtFloat16)
                                         continue;
-                                    if (lodClamp && (proj || lod || fetch))
-                                        continue;
-
-                                    for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
+                                    if (f16TexAddr && sampler.shadow && ! compare) {
+                                        compare = true; // compare argument is always present
+                                        totalDims--;
+                                    }
+#endif
+                                    for (int lodClamp = 0; lodClamp <= 1 ;++lodClamp) { // loop over "bool" lod clamp
 
-                                        if (sparse && (profile == EEsProfile || version < 450))
+                                        if (lodClamp && (profile == EEsProfile || version < 450))
                                             continue;
-                                        // Sparse sampling is not for 1D/1D array texture, buffer texture, and projective texture
-                                        if (sparse && (sampler.dim == Esd1D || sampler.dim == EsdBuffer || proj))
+                                        if (lodClamp && (proj || lod || fetch))
                                             continue;
 
-                                        TString s;
+                                        for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
+
+                                            if (sparse && (profile == EEsProfile || version < 450))
+                                                continue;
+                                            // Sparse sampling is not for 1D/1D array texture, buffer texture, and projective texture
+                                            if (sparse && (sampler.dim == Esd1D || sampler.dim == EsdBuffer || proj))
+                                                continue;
+
+                                            TString s;
 
-                                        // return type
-                                        if (sparse)
-                                            s.append("int ");
-                                        else {
-                                            if (sampler.shadow)
-                                                s.append("float ");
+                                            // return type
+                                            if (sparse)
+                                                s.append("int ");
                                             else {
-                                                s.append(prefixes[sampler.type]);
-                                                s.append("vec4 ");
+                                                if (sampler.shadow)
+#ifdef AMD_EXTENSIONS
+                                                    if (sampler.type == EbtFloat16)
+                                                        s.append("float16_t ");
+                                                    else
+                                                        s.append("float ");
+#else
+                                                    s.append("float ");
+#endif
+                                                else {
+                                                    s.append(prefixes[sampler.type]);
+                                                    s.append("vec4 ");
+                                                }
                                             }
-                                        }
 
-                                        // name
-                                        if (sparse) {
-                                            if (fetch)
-                                                s.append("sparseTexel");
-                                            else
-                                                s.append("sparseTexture");
-                                        } else {
-                                            if (fetch)
-                                                s.append("texel");
-                                            else
-                                                s.append("texture");
-                                        }
-                                        if (proj)
-                                            s.append("Proj");
-                                        if (lod)
-                                            s.append("Lod");
-                                        if (grad)
-                                            s.append("Grad");
-                                        if (fetch)
-                                            s.append("Fetch");
-                                        if (offset)
-                                            s.append("Offset");
-                                        if (lodClamp)
-                                            s.append("Clamp");
-                                        if (lodClamp || sparse)
-                                            s.append("ARB");
-                                        s.append("(");
-
-                                        // sampler type
-                                        s.append(typeName);
-
-                                        // P coordinate
-                                        if (extraProj)
-                                            s.append(",vec4");
-                                        else {
-                                            s.append(",");
-                                            TBasicType t = fetch ? EbtInt : EbtFloat;
-                                            if (totalDims == 1)
-                                                s.append(TType::getBasicString(t));
+                                            // name
+                                            if (sparse) {
+                                                if (fetch)
+                                                    s.append("sparseTexel");
+                                                else
+                                                    s.append("sparseTexture");
+                                            }
                                             else {
-                                                s.append(prefixes[t]);
-                                                s.append("vec");
-                                                s.append(postfixes[totalDims]);
+                                                if (fetch)
+                                                    s.append("texel");
+                                                else
+                                                    s.append("texture");
                                             }
-                                        }
-
-                                        if (bias && compare)
-                                            continue;
-
-                                        // non-optional lod argument (lod that's not driven by lod loop) or sample
-                                        if ((fetch && sampler.dim != EsdBuffer && sampler.dim != EsdRect && !sampler.ms) ||
-                                            (sampler.ms && fetch))
-                                            s.append(",int");
-
-                                        // non-optional lod
-                                        if (lod)
-                                            s.append(",float");
-
-                                        // gradient arguments
-                                        if (grad) {
-                                            if (dimMap[sampler.dim] == 1)
-                                                s.append(",float,float");
+                                            if (proj)
+                                                s.append("Proj");
+                                            if (lod)
+                                                s.append("Lod");
+                                            if (grad)
+                                                s.append("Grad");
+                                            if (fetch)
+                                                s.append("Fetch");
+                                            if (offset)
+                                                s.append("Offset");
+                                            if (lodClamp)
+                                                s.append("Clamp");
+                                            if (lodClamp || sparse)
+                                                s.append("ARB");
+                                            s.append("(");
+
+                                            // sampler type
+                                            s.append(typeName);
+#ifdef AMD_EXTENSIONS
+                                            // P coordinate
+                                            if (extraProj) {
+                                                if (f16TexAddr)
+                                                    s.append(",f16vec4");
+                                                else
+                                                    s.append(",vec4");
+                                            } else {
+                                                s.append(",");
+                                                TBasicType t = fetch ? EbtInt : (f16TexAddr ? EbtFloat16 : EbtFloat);
+                                                if (totalDims == 1)
+                                                    s.append(TType::getBasicString(t));
+                                                else {
+                                                    s.append(prefixes[t]);
+                                                    s.append("vec");
+                                                    s.append(postfixes[totalDims]);
+                                                }
+                                            }
+#else
+                                            // P coordinate
+                                            if (extraProj)
+                                                s.append(",vec4");
                                             else {
-                                                s.append(",vec");
-                                                s.append(postfixes[dimMap[sampler.dim]]);
-                                                s.append(",vec");
-                                                s.append(postfixes[dimMap[sampler.dim]]);
+                                                s.append(",");
+                                                TBasicType t = fetch ? EbtInt : EbtFloat;
+                                                if (totalDims == 1)
+                                                    s.append(TType::getBasicString(t));
+                                                else {
+                                                    s.append(prefixes[t]);
+                                                    s.append("vec");
+                                                    s.append(postfixes[totalDims]);
+                                                }
                                             }
-                                        }
+#endif
+                                            // non-optional compare
+                                            if (compare)
+                                                s.append(",float");
 
-                                        // offset
-                                        if (offset) {
-                                            if (dimMap[sampler.dim] == 1)
+                                            // non-optional lod argument (lod that's not driven by lod loop) or sample
+                                            if ((fetch && sampler.dim != EsdBuffer && sampler.dim != EsdRect && !sampler.ms) ||
+                                                (sampler.ms && fetch))
                                                 s.append(",int");
-                                            else {
-                                                s.append(",ivec");
-                                                s.append(postfixes[dimMap[sampler.dim]]);
+#ifdef AMD_EXTENSIONS
+                                            // non-optional lod
+                                            if (lod) {
+                                                if (f16TexAddr)
+                                                    s.append(",float16_t");
+                                                else
+                                                    s.append(",float");
                                             }
-                                        }
-
-                                        // non-optional compare
-                                        if (compare)
-                                            s.append(",float");
 
-                                        // lod clamp
-                                        if (lodClamp)
-                                            s.append(",float");
-
-                                        // texel out (for sparse texture)
-                                        if (sparse) {
-                                            s.append(",out ");
-                                            if (sampler.shadow)
-                                                s.append("float ");
-                                            else {
-                                                s.append(prefixes[sampler.type]);
-                                                s.append("vec4 ");
+                                            // gradient arguments
+                                            if (grad) {
+                                                if (dimMap[sampler.dim] == 1) {
+                                                    if (f16TexAddr)
+                                                        s.append(",float16_t,float16_t");
+                                                    else
+                                                        s.append(",float,float");
+                                                } else {
+                                                    if (f16TexAddr)
+                                                        s.append(",f16vec");
+                                                    else
+                                                        s.append(",vec");
+                                                    s.append(postfixes[dimMap[sampler.dim]]);
+                                                    if (f16TexAddr)
+                                                        s.append(",f16vec");
+                                                    else
+                                                        s.append(",vec");
+                                                    s.append(postfixes[dimMap[sampler.dim]]);
+                                                }
+                                            }
+#else
+                                            // non-optional lod
+                                            if (lod)
+                                                s.append(",float");
+
+                                            // gradient arguments
+                                            if (grad) {
+                                                if (dimMap[sampler.dim] == 1)
+                                                    s.append(",float,float");
+                                                else {
+                                                    s.append(",vec");
+                                                    s.append(postfixes[dimMap[sampler.dim]]);
+                                                    s.append(",vec");
+                                                    s.append(postfixes[dimMap[sampler.dim]]);
+                                                }
+                                            }
+#endif
+                                            // offset
+                                            if (offset) {
+                                                if (dimMap[sampler.dim] == 1)
+                                                    s.append(",int");
+                                                else {
+                                                    s.append(",ivec");
+                                                    s.append(postfixes[dimMap[sampler.dim]]);
+                                                }
                                             }
-                                        }
-
-                                        // optional bias
-                                        if (bias)
-                                            s.append(",float");
 
-                                        s.append(");\n");
+#ifdef AMD_EXTENSIONS
+                                            // lod clamp
+                                            if (lodClamp) {
+                                                if (f16TexAddr)
+                                                    s.append(",float16_t");
+                                                else
+                                                    s.append(",float");
+                                            }
+#else
+                                            // lod clamp
+                                            if (lodClamp)
+                                                s.append(",float");
+#endif
+                                            // texel out (for sparse texture)
+                                            if (sparse) {
+                                                s.append(",out ");
+                                                if (sampler.shadow)
+#ifdef AMD_EXTENSIONS
+                                                    if (sampler.type == EbtFloat16)
+                                                        s.append("float16_t");
+                                                    else
+                                                        s.append("float");
+#else
+                                                    s.append("float");
+#endif
+                                                else {
+                                                    s.append(prefixes[sampler.type]);
+                                                    s.append("vec4");
+                                                }
+                                            }
+#ifdef AMD_EXTENSIONS
+                                            // optional bias
+                                            if (bias) {
+                                                if (f16TexAddr)
+                                                    s.append(",float16_t");
+                                                else
+                                                    s.append(",float");
+                                            }
+#else
+                                            // optional bias
+                                            if (bias)
+                                                s.append(",float");
+#endif
+                                            s.append(");\n");
 
-                                        // Add to the per-language set of built-ins
+                                            // Add to the per-language set of built-ins
+                                            if (bias || lodClamp)
+                                                stageBuiltins[EShLangFragment].append(s);
+                                            else
+                                                commonBuiltins.append(s);
 
-                                        if (bias || lodClamp)
-                                            stageBuiltins[EShLangFragment].append(s);
-                                        else
-                                            commonBuiltins.append(s);
+                                        }
                                     }
+#ifdef AMD_EXTENSIONS
                                 }
+#endif
                             }
                         }
                     }
@@ -4645,81 +4769,96 @@ void TBuiltIns::addGatherFunctions(TSampler sampler, const TString& typeName, in
     if (version < 140 && sampler.dim == EsdRect && sampler.type != EbtFloat)
         return;
 
-    for (int offset = 0; offset < 3; ++offset) { // loop over three forms of offset in the call name:  none, Offset, and Offsets
+#ifdef AMD_EXTENSIONS
+    for (int f16TexAddr = 0; f16TexAddr <= 1; ++f16TexAddr) { // loop over 16-bit floating-point texel addressing
 
-        for (int comp = 0; comp < 2; ++comp) { // loop over presence of comp argument
+        if (f16TexAddr && sampler.type != EbtFloat16)
+            continue;
+#endif
+        for (int offset = 0; offset < 3; ++offset) { // loop over three forms of offset in the call name:  none, Offset, and Offsets
 
-            if (comp > 0 && sampler.shadow)
-                continue;
+            for (int comp = 0; comp < 2; ++comp) { // loop over presence of comp argument
 
-            if (offset > 0 && sampler.dim == EsdCube)
-                continue;
+                if (comp > 0 && sampler.shadow)
+                    continue;
 
-            for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
-                if (sparse && (profile == EEsProfile || version < 450))
+                if (offset > 0 && sampler.dim == EsdCube)
                     continue;
 
-                TString s;
+                for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
+                    if (sparse && (profile == EEsProfile || version < 450))
+                        continue;
 
-                // return type
-                if (sparse)
-                    s.append("int ");
-                else {
-                    s.append(prefixes[sampler.type]);
-                    s.append("vec4 ");
-                }
+                    TString s;
 
-                // name
-                if (sparse)
-                    s.append("sparseTextureGather");
-                else
-                    s.append("textureGather");
-                switch (offset) {
-                case 1:
-                    s.append("Offset");
-                    break;
-                case 2:
-                    s.append("Offsets");
-                default:
-                    break;
-                }
+                    // return type
+                    if (sparse)
+                        s.append("int ");
+                    else {
+                        s.append(prefixes[sampler.type]);
+                        s.append("vec4 ");
+                    }
 
-                if (sparse)
-                    s.append("ARB");
-                s.append("(");
+                    // name
+                    if (sparse)
+                        s.append("sparseTextureGather");
+                    else
+                        s.append("textureGather");
+                    switch (offset) {
+                    case 1:
+                        s.append("Offset");
+                        break;
+                    case 2:
+                        s.append("Offsets");
+                    default:
+                        break;
+                    }
+                    if (sparse)
+                        s.append("ARB");
+                    s.append("(");
 
-                // sampler type argument
-                s.append(typeName);
+                    // sampler type argument
+                    s.append(typeName);
 
-                // P coordinate argument
-                s.append(",vec");
-                int totalDims = dimMap[sampler.dim] + (sampler.arrayed ? 1 : 0);
-                s.append(postfixes[totalDims]);
+                    // P coordinate argument
+#ifdef AMD_EXTENSIONS
+                    if (f16TexAddr)
+                        s.append(",f16vec");
+                    else
+                        s.append(",vec");
+#else
+                    s.append(",vec");
+#endif
+                    int totalDims = dimMap[sampler.dim] + (sampler.arrayed ? 1 : 0);
+                    s.append(postfixes[totalDims]);
+
+                    // refZ argument
+                    if (sampler.shadow)
+                        s.append(",float");
+
+                    // offset argument
+                    if (offset > 0) {
+                        s.append(",ivec2");
+                        if (offset == 2)
+                            s.append("[4]");
+                    }
 
-                // refZ argument
-                if (sampler.shadow)
-                    s.append(",float");
+                    // texel out (for sparse texture)
+                    if (sparse) {
+                        s.append(",out ");
+                        s.append(prefixes[sampler.type]);
+                        s.append("vec4 ");
+                    }
 
-                // offset argument
-                if (offset > 0) {
-                    s.append(",ivec2");
-                    if (offset == 2)
-                        s.append("[4]");
-                }
+                    // comp argument
+                    if (comp)
+                        s.append(",int");
 
-                // texel out (for sparse texture)
-                if (sparse) {
-                    s.append(",out ");
-                    s.append(prefixes[sampler.type]);
-                    s.append("vec4 ");
+                    s.append(");\n");
+                    commonBuiltins.append(s);
+#ifdef AMD_EXTENSIONS
                 }
-
-                // comp argument
-                if (comp)
-                    s.append(",int");
-
-                s.append(");\n");
-                commonBuiltins.append(s);
+#endif
             }
         }
     }
@@ -4738,95 +4877,112 @@ void TBuiltIns::addGatherFunctions(TSampler sampler, const TString& typeName, in
             if ((lod && bias) || (lod == 0 && bias == 0))
                 continue;
 
-            for (int offset = 0; offset < 3; ++offset) { // loop over three forms of offset in the call name:  none, Offset, and Offsets
+            for (int f16TexAddr = 0; f16TexAddr <= 1; ++f16TexAddr) { // loop over 16-bit floating-point texel addressing
 
-                for (int comp = 0; comp < 2; ++comp) { // loop over presence of comp argument
+                if (f16TexAddr && sampler.type != EbtFloat16)
+                    continue;
 
-                    if (comp == 0 && bias)
-                        continue;
+                for (int offset = 0; offset < 3; ++offset) { // loop over three forms of offset in the call name:  none, Offset, and Offsets
 
-                    if (offset > 0 && sampler.dim == EsdCube)
-                        continue;
+                    for (int comp = 0; comp < 2; ++comp) { // loop over presence of comp argument
 
-                    for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
-                        if (sparse && (profile == EEsProfile || version < 450))
+                        if (comp == 0 && bias)
                             continue;
 
-                        TString s;
+                        if (offset > 0 && sampler.dim == EsdCube)
+                            continue;
 
-                        // return type
-                        if (sparse)
-                            s.append("int ");
-                        else {
-                            s.append(prefixes[sampler.type]);
-                            s.append("vec4 ");
-                        }
+                        for (int sparse = 0; sparse <= 1; ++sparse) { // loop over "bool" sparse or not
+                            if (sparse && (profile == EEsProfile || version < 450))
+                                continue;
 
-                        // name
-                        if (sparse)
-                            s.append("sparseTextureGather");
-                        else
-                            s.append("textureGather");
-
-                        if (lod)
-                            s.append("Lod");
-
-                        switch (offset) {
-                        case 1:
-                            s.append("Offset");
-                            break;
-                        case 2:
-                            s.append("Offsets");
-                        default:
-                            break;
-                        }
+                            TString s;
 
-                        if (lod)
-                            s.append("AMD");
-                        else if (sparse)
-                            s.append("ARB");
+                            // return type
+                            if (sparse)
+                                s.append("int ");
+                            else {
+                                s.append(prefixes[sampler.type]);
+                                s.append("vec4 ");
+                            }
 
-                        s.append("(");
+                            // name
+                            if (sparse)
+                                s.append("sparseTextureGather");
+                            else
+                                s.append("textureGather");
+
+                            if (lod)
+                                s.append("Lod");
+
+                            switch (offset) {
+                            case 1:
+                                s.append("Offset");
+                                break;
+                            case 2:
+                                s.append("Offsets");
+                            default:
+                                break;
+                            }
 
-                        // sampler type argument
-                        s.append(typeName);
+                            if (lod)
+                                s.append("AMD");
+                            else if (sparse)
+                                s.append("ARB");
+
+                            s.append("(");
+
+                            // sampler type argument
+                            s.append(typeName);
+
+                            // P coordinate argument
+                            if (f16TexAddr)
+                                s.append(",f16vec");
+                            else
+                                s.append(",vec");
+                            int totalDims = dimMap[sampler.dim] + (sampler.arrayed ? 1 : 0);
+                            s.append(postfixes[totalDims]);
+
+                            // lod argument
+                            if (lod) {
+                                if (f16TexAddr)
+                                    s.append(",float16_t");
+                                else
+                                    s.append(",float");
+                            }
 
-                        // P coordinate argument
-                        s.append(",vec");
-                        int totalDims = dimMap[sampler.dim] + (sampler.arrayed ? 1 : 0);
-                        s.append(postfixes[totalDims]);
-
-                        // lod argument
-                        if (lod)
-                            s.append(",float");
-
-                        // offset argument
-                        if (offset > 0) {
-                            s.append(",ivec2");
-                            if (offset == 2)
-                                s.append("[4]");
-                        }
+                            // offset argument
+                            if (offset > 0) {
+                                s.append(",ivec2");
+                                if (offset == 2)
+                                    s.append("[4]");
+                            }
 
-                        // texel out (for sparse texture)
-                        if (sparse) {
-                            s.append(",out ");
-                            s.append(prefixes[sampler.type]);
-                            s.append("vec4 ");
-                        }
+                            // texel out (for sparse texture)
+                            if (sparse) {
+                                s.append(",out ");
+                                s.append(prefixes[sampler.type]);
+                                s.append("vec4 ");
+                            }
 
-                        // comp argument
-                        if (comp)
-                            s.append(",int");
+                            // comp argument
+                            if (comp)
+                                s.append(",int");
 
-                        // bias argument
-                        if (bias)
-                            s.append(",float");
+                            // bias argument
+                            if (bias) {
+                                if (f16TexAddr)
+                                    s.append(",float16_t");
+                                else
+                                    s.append(",float");
+                            }
 
-                        s.append(");\n");
-                        if (bias)
-                            stageBuiltins[EShLangFragment].append(s);
-                        else
-                            commonBuiltins.append(s);
+                            s.append(");\n");
+                            if (bias)
+                                stageBuiltins[EShLangFragment].append(s);
+                            else
+                                commonBuiltins.append(s);
+                        }
                     }
                 }
             }

+ 6 - 0
glslang/MachineIndependent/ParseHelper.cpp

@@ -1520,6 +1520,12 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
         }
 
         if (arg > 0) {
+
+#ifdef AMD_EXTENSIONS
+            bool f16ShadowCompare = (*argp)[1]->getAsTyped()->getBasicType() == EbtFloat16 && arg0->getType().getSampler().shadow;
+            if (f16ShadowCompare)
+                ++arg;
+#endif
             if (! (*argp)[arg]->getAsConstantUnion())
                 error(loc, "argument must be compile-time constant", "texel offset", "");
             else {

+ 103 - 0
glslang/MachineIndependent/Scan.cpp

@@ -579,6 +579,54 @@ void TScanContext::fillInKeywordMap()
     (*KeywordMap)["usubpassInput"] =           USUBPASSINPUT;
     (*KeywordMap)["usubpassInputMS"] =         USUBPASSINPUTMS;
 
+#ifdef AMD_EXTENSIONS
+    (*KeywordMap)["f16sampler1D"] =                 F16SAMPLER1D;
+    (*KeywordMap)["f16sampler2D"] =                 F16SAMPLER2D;
+    (*KeywordMap)["f16sampler3D"] =                 F16SAMPLER3D;
+    (*KeywordMap)["f16sampler2DRect"] =             F16SAMPLER2DRECT;
+    (*KeywordMap)["f16samplerCube"] =               F16SAMPLERCUBE;
+    (*KeywordMap)["f16sampler1DArray"] =            F16SAMPLER1DARRAY;
+    (*KeywordMap)["f16sampler2DArray"] =            F16SAMPLER2DARRAY;
+    (*KeywordMap)["f16samplerCubeArray"] =          F16SAMPLERCUBEARRAY;
+    (*KeywordMap)["f16samplerBuffer"] =             F16SAMPLERBUFFER;
+    (*KeywordMap)["f16sampler2DMS"] =               F16SAMPLER2DMS;
+    (*KeywordMap)["f16sampler2DMSArray"] =          F16SAMPLER2DMSARRAY;
+    (*KeywordMap)["f16sampler1DShadow"] =           F16SAMPLER1DSHADOW;
+    (*KeywordMap)["f16sampler2DShadow"] =           F16SAMPLER2DSHADOW;
+    (*KeywordMap)["f16sampler2DRectShadow"] =       F16SAMPLER2DRECTSHADOW;
+    (*KeywordMap)["f16samplerCubeShadow"] =         F16SAMPLERCUBESHADOW;
+    (*KeywordMap)["f16sampler1DArrayShadow"] =      F16SAMPLER1DARRAYSHADOW;
+    (*KeywordMap)["f16sampler2DArrayShadow"] =      F16SAMPLER2DARRAYSHADOW;
+    (*KeywordMap)["f16samplerCubeArrayShadow"] =    F16SAMPLERCUBEARRAYSHADOW;
+
+    (*KeywordMap)["f16image1D"] =                   F16IMAGE1D;
+    (*KeywordMap)["f16image2D"] =                   F16IMAGE2D;
+    (*KeywordMap)["f16image3D"] =                   F16IMAGE3D;
+    (*KeywordMap)["f16image2DRect"] =               F16IMAGE2DRECT;
+    (*KeywordMap)["f16imageCube"] =                 F16IMAGECUBE;
+    (*KeywordMap)["f16image1DArray"] =              F16IMAGE1DARRAY;
+    (*KeywordMap)["f16image2DArray"] =              F16IMAGE2DARRAY;
+    (*KeywordMap)["f16imageCubeArray"] =            F16IMAGECUBEARRAY;
+    (*KeywordMap)["f16imageBuffer"] =               F16IMAGEBUFFER;
+    (*KeywordMap)["f16image2DMS"] =                 F16IMAGE2DMS;
+    (*KeywordMap)["f16image2DMSArray"] =            F16IMAGE2DMSARRAY;
+
+    (*KeywordMap)["f16texture1D"] =                 F16TEXTURE1D;
+    (*KeywordMap)["f16texture2D"] =                 F16TEXTURE2D;
+    (*KeywordMap)["f16texture3D"] =                 F16TEXTURE3D;
+    (*KeywordMap)["f16texture2DRect"] =             F16TEXTURE2DRECT;
+    (*KeywordMap)["f16textureCube"] =               F16TEXTURECUBE;
+    (*KeywordMap)["f16texture1DArray"] =            F16TEXTURE1DARRAY;
+    (*KeywordMap)["f16texture2DArray"] =            F16TEXTURE2DARRAY;
+    (*KeywordMap)["f16textureCubeArray"] =          F16TEXTURECUBEARRAY;
+    (*KeywordMap)["f16textureBuffer"] =             F16TEXTUREBUFFER;
+    (*KeywordMap)["f16texture2DMS"] =               F16TEXTURE2DMS;
+    (*KeywordMap)["f16texture2DMSArray"] =          F16TEXTURE2DMSARRAY;
+
+    (*KeywordMap)["f16subpassInput"] =              F16SUBPASSINPUT;
+    (*KeywordMap)["f16subpassInputMS"] =            F16SUBPASSINPUTMS;
+#endif
+
     (*KeywordMap)["noperspective"] =           NOPERSPECTIVE;
     (*KeywordMap)["smooth"] =                  SMOOTH;
     (*KeywordMap)["flat"] =                    FLAT;
@@ -1029,6 +1077,7 @@ int TScanContext::tokenizeIdentifier()
             (parseContext.profile != EEsProfile && parseContext.version >= 450 &&
              parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float)))
             return keyword;
+
         return identifierOrType();
 #endif
 
@@ -1211,6 +1260,60 @@ int TScanContext::tokenizeIdentifier()
         else
             return identifierOrType();
 
+#ifdef AMD_EXTENSIONS
+    case F16SAMPLER1D:
+    case F16SAMPLER2D:
+    case F16SAMPLER3D:
+    case F16SAMPLER2DRECT:
+    case F16SAMPLERCUBE:
+    case F16SAMPLER1DARRAY:
+    case F16SAMPLER2DARRAY:
+    case F16SAMPLERCUBEARRAY:
+    case F16SAMPLERBUFFER:
+    case F16SAMPLER2DMS:
+    case F16SAMPLER2DMSARRAY:
+    case F16SAMPLER1DSHADOW:
+    case F16SAMPLER2DSHADOW:
+    case F16SAMPLER1DARRAYSHADOW:
+    case F16SAMPLER2DARRAYSHADOW:
+    case F16SAMPLER2DRECTSHADOW:
+    case F16SAMPLERCUBESHADOW:
+    case F16SAMPLERCUBEARRAYSHADOW:
+
+    case F16IMAGE1D:
+    case F16IMAGE2D:
+    case F16IMAGE3D:
+    case F16IMAGE2DRECT:
+    case F16IMAGECUBE:
+    case F16IMAGE1DARRAY:
+    case F16IMAGE2DARRAY:
+    case F16IMAGECUBEARRAY:
+    case F16IMAGEBUFFER:
+    case F16IMAGE2DMS:
+    case F16IMAGE2DMSARRAY:
+
+    case F16TEXTURE1D:
+    case F16TEXTURE2D:
+    case F16TEXTURE3D:
+    case F16TEXTURE2DRECT:
+    case F16TEXTURECUBE:
+    case F16TEXTURE1DARRAY:
+    case F16TEXTURE2DARRAY:
+    case F16TEXTURECUBEARRAY:
+    case F16TEXTUREBUFFER:
+    case F16TEXTURE2DMS:
+    case F16TEXTURE2DMSARRAY:
+
+    case F16SUBPASSINPUT:
+    case F16SUBPASSINPUTMS:
+        afterType = true;
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            (parseContext.extensionTurnedOn(E_GL_AMD_gpu_shader_half_float_fetch) &&
+             parseContext.profile != EEsProfile && parseContext.version >= 450))
+            return keyword;
+        return identifierOrType();
+#endif
+
     case NOPERSPECTIVE:
         return es30ReservedFromGLSL(130);
 

+ 3 - 0
glslang/MachineIndependent/SymbolTable.cpp

@@ -75,6 +75,9 @@ void TType::buildMangledName(TString& mangledName) const
     case EbtAtomicUint:         mangledName += "au";     break;
     case EbtSampler:
         switch (sampler.type) {
+#ifdef AMD_EXTENSIONS
+        case EbtFloat16: mangledName += "f16"; break;
+#endif
         case EbtInt:   mangledName += "i"; break;
         case EbtUint:  mangledName += "u"; break;
         default: break; // some compilers want this

+ 16 - 3
glslang/MachineIndependent/Versions.cpp

@@ -204,6 +204,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_AMD_gpu_shader_int16]                     = EBhDisable;
     extensionBehavior[E_GL_AMD_shader_image_load_store_lod]          = EBhDisable;
     extensionBehavior[E_GL_AMD_shader_fragment_mask]                 = EBhDisable;
+    extensionBehavior[E_GL_AMD_gpu_shader_half_float_fetch]          = EBhDisable;
 #endif
 
 #ifdef NV_EXTENSIONS
@@ -341,6 +342,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_AMD_gpu_shader_int16 1\n"
             "#define GL_AMD_shader_image_load_store_lod 1\n"
             "#define GL_AMD_shader_fragment_mask 1\n"
+            "#define GL_AMD_gpu_shader_half_float_fetch 1\n"
 #endif
 
 #ifdef NV_EXTENSIONS
@@ -749,7 +751,7 @@ void TParseVersions::doubleCheck(const TSourceLoc& loc, const char* op)
 void TParseVersions::int16Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (! builtIn) {
-        requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_int16, "shader int16");
+        requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_int16, op);
         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
         profileRequires(loc, ECoreProfile, 450, nullptr, op);
         profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);
@@ -760,7 +762,18 @@ void TParseVersions::int16Check(const TSourceLoc& loc, const char* op, bool buil
 void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (! builtIn) {
-        requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float, "shader half float");
+        requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float, op);
+        requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
+        profileRequires(loc, ECoreProfile, 450, nullptr, op);
+        profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);
+    }
+}
+
+// Call for any operation needing GLSL float16 opaque-type support
+void TParseVersions::float16OpaqueCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (! builtIn) {
+        requireExtensions(loc, 1, &E_GL_AMD_gpu_shader_half_float_fetch, op);
         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
         profileRequires(loc, ECoreProfile, 450, nullptr, op);
         profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);
@@ -772,7 +785,7 @@ void TParseVersions::float16Check(const TSourceLoc& loc, const char* op, bool bu
 void TParseVersions::int64Check(const TSourceLoc& loc, const char* op, bool builtIn)
 {
     if (! builtIn) {
-        requireExtensions(loc, 1, &E_GL_ARB_gpu_shader_int64, "shader int64");
+        requireExtensions(loc, 1, &E_GL_ARB_gpu_shader_int64, op);
         requireProfile(loc, ECoreProfile | ECompatibilityProfile, op);
         profileRequires(loc, ECoreProfile, 450, nullptr, op);
         profileRequires(loc, ECompatibilityProfile, 450, nullptr, op);

+ 1 - 0
glslang/MachineIndependent/Versions.h

@@ -174,6 +174,7 @@ const char* const E_GL_AMD_texture_gather_bias_lod              = "GL_AMD_textur
 const char* const E_GL_AMD_gpu_shader_int16                     = "GL_AMD_gpu_shader_int16";
 const char* const E_GL_AMD_shader_image_load_store_lod          = "GL_AMD_shader_image_load_store_lod";
 const char* const E_GL_AMD_shader_fragment_mask                 = "GL_AMD_shader_fragment_mask";
+const char* const E_GL_AMD_gpu_shader_half_float_fetch          = "GL_AMD_gpu_shader_half_float_fetch";
 #endif
 
 #ifdef NV_EXTENSIONS

+ 34 - 0
glslang/MachineIndependent/gl_types.h

@@ -117,6 +117,40 @@
 #define GL_SAMPLER_CUBE_MAP_ARRAY_ARB     0x900C
 #define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB 0x900D
 
+#ifdef AMD_EXTENSIONS
+#define GL_FLOAT16_SAMPLER_1D_AMD                       0x91CE
+#define GL_FLOAT16_SAMPLER_2D_AMD                       0x91CF
+#define GL_FLOAT16_SAMPLER_3D_AMD                       0x91D0
+#define GL_FLOAT16_SAMPLER_CUBE_AMD                     0x91D1
+#define GL_FLOAT16_SAMPLER_2D_RECT_AMD                  0x91D2
+#define GL_FLOAT16_SAMPLER_1D_ARRAY_AMD                 0x91D3
+#define GL_FLOAT16_SAMPLER_2D_ARRAY_AMD                 0x91D4
+#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD           0x91D5
+#define GL_FLOAT16_SAMPLER_BUFFER_AMD                   0x91D6
+#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD           0x91D7
+#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD     0x91D8
+
+#define GL_FLOAT16_SAMPLER_1D_SHADOW_AMD                0x91D9
+#define GL_FLOAT16_SAMPLER_2D_SHADOW_AMD                0x91DA
+#define GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD           0x91DB
+#define GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD          0x91DC
+#define GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD          0x91DD
+#define GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD              0x91DE
+#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD    0x91DF
+
+#define GL_FLOAT16_IMAGE_1D_AMD                         0x91E0
+#define GL_FLOAT16_IMAGE_2D_AMD                         0x91E1
+#define GL_FLOAT16_IMAGE_3D_AMD                         0x91E2
+#define GL_FLOAT16_IMAGE_2D_RECT_AMD                    0x91E3
+#define GL_FLOAT16_IMAGE_CUBE_AMD                       0x91E4
+#define GL_FLOAT16_IMAGE_1D_ARRAY_AMD                   0x91E5
+#define GL_FLOAT16_IMAGE_2D_ARRAY_AMD                   0x91E6
+#define GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD             0x91E7
+#define GL_FLOAT16_IMAGE_BUFFER_AMD                     0x91E8
+#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD             0x91E9
+#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD       0x91EA
+#endif
+
 #define GL_INT_SAMPLER_1D                 0x8DC9
 #define GL_INT_SAMPLER_2D                 0x8DCA
 #define GL_INT_SAMPLER_3D                 0x8DCB

+ 353 - 0
glslang/MachineIndependent/glslang.y

@@ -159,6 +159,12 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> SAMPLER2DMSARRAY ISAMPLER2DMSARRAY USAMPLER2DMSARRAY
 %token <lex> SAMPLEREXTERNALOES
 
+%token <lex> F16SAMPLER1D F16SAMPLER2D F16SAMPLER3D F16SAMPLER2DRECT F16SAMPLERCUBE
+%token <lex> F16SAMPLER1DARRAY F16SAMPLER2DARRAY F16SAMPLERCUBEARRAY
+%token <lex> F16SAMPLERBUFFER F16SAMPLER2DMS F16SAMPLER2DMSARRAY
+%token <lex> F16SAMPLER1DSHADOW F16SAMPLER2DSHADOW F16SAMPLER1DARRAYSHADOW F16SAMPLER2DARRAYSHADOW
+%token <lex> F16SAMPLER2DRECTSHADOW F16SAMPLERCUBESHADOW F16SAMPLERCUBEARRAYSHADOW
+
 // pure sampler
 %token <lex> SAMPLER SAMPLERSHADOW
 
@@ -174,8 +180,13 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> TEXTURE2DMS ITEXTURE2DMS UTEXTURE2DMS
 %token <lex> TEXTURE2DMSARRAY ITEXTURE2DMSARRAY UTEXTURE2DMSARRAY
 
+%token <lex> F16TEXTURE1D F16TEXTURE2D F16TEXTURE3D F16TEXTURE2DRECT F16TEXTURECUBE
+%token <lex> F16TEXTURE1DARRAY F16TEXTURE2DARRAY F16TEXTURECUBEARRAY
+%token <lex> F16TEXTUREBUFFER F16TEXTURE2DMS F16TEXTURE2DMSARRAY
+
 // input attachments
 %token <lex> SUBPASSINPUT SUBPASSINPUTMS ISUBPASSINPUT ISUBPASSINPUTMS USUBPASSINPUT USUBPASSINPUTMS
+%token <lex> F16SUBPASSINPUT F16SUBPASSINPUTMS
 
 %token <lex> IMAGE1D IIMAGE1D UIMAGE1D IMAGE2D IIMAGE2D
 %token <lex> UIMAGE2D IMAGE3D IIMAGE3D UIMAGE3D
@@ -188,6 +199,10 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> IMAGE2DMS IIMAGE2DMS UIMAGE2DMS
 %token <lex> IMAGE2DMSARRAY IIMAGE2DMSARRAY UIMAGE2DMSARRAY
 
+%token <lex> F16IMAGE1D F16IMAGE2D F16IMAGE3D F16IMAGE2DRECT
+%token <lex> F16IMAGECUBE F16IMAGE1DARRAY F16IMAGE2DARRAY F16IMAGECUBEARRAY
+%token <lex> F16IMAGEBUFFER F16IMAGE2DMS F16IMAGE2DMSARRAY
+
 %token <lex> STRUCT VOID WHILE
 
 %token <lex> IDENTIFIER TYPE_NAME
@@ -1890,6 +1905,110 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.set(EbtFloat, EsdCube, true, true);
     }
+    | F16SAMPLER1D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd1D);
+#endif
+    }
+    | F16SAMPLER2D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D);
+#endif
+    }
+    | F16SAMPLER3D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd3D);
+#endif
+    }
+    | F16SAMPLERCUBE {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdCube);
+#endif
+    }
+    | F16SAMPLER1DSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd1D, false, true);
+#endif
+    }
+    | F16SAMPLER2DSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D, false, true);
+#endif
+    }
+    | F16SAMPLERCUBESHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdCube, false, true);
+#endif
+    }
+    | F16SAMPLER1DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd1D, true);
+#endif
+    }
+    | F16SAMPLER2DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D, true);
+#endif
+    }
+    | F16SAMPLER1DARRAYSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd1D, true, true);
+#endif
+    }
+    | F16SAMPLER2DARRAYSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D, true, true);
+#endif
+    }
+    | F16SAMPLERCUBEARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdCube, true);
+#endif
+    }
+    | F16SAMPLERCUBEARRAYSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdCube, true, true);
+#endif
+    }
     | ISAMPLER1D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -1970,6 +2089,22 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.set(EbtFloat, EsdRect, false, true);
     }
+    | F16SAMPLER2DRECT {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdRect);
+#endif
+    }
+    | F16SAMPLER2DRECTSHADOW {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdRect, false, true);
+#endif
+    }
     | ISAMPLER2DRECT {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -1985,6 +2120,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.set(EbtFloat, EsdBuffer);
     }
+    | F16SAMPLERBUFFER {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, EsdBuffer);
+#endif
+    }
     | ISAMPLERBUFFER {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2000,6 +2143,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.set(EbtFloat, Esd2D, false, false, true);
     }
+    | F16SAMPLER2DMS {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D, false, false, true);
+#endif
+    }
     | ISAMPLER2DMS {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2015,6 +2166,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.set(EbtFloat, Esd2D, true, false, true);
     }
+    | F16SAMPLER2DMSARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float sampler", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.set(EbtFloat16, Esd2D, true, false, true);
+#endif
+    }
     | ISAMPLER2DMSARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2040,36 +2199,92 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd1D);
     }
+    | F16TEXTURE1D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd1D);
+#endif
+    }
     | TEXTURE2D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd2D);
     }
+    | F16TEXTURE2D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd2D);
+#endif
+    }
     | TEXTURE3D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd3D);
     }
+    | F16TEXTURE3D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd3D);
+#endif
+    }
     | TEXTURECUBE {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, EsdCube);
     }
+    | F16TEXTURECUBE {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, EsdCube);
+#endif
+    }
     | TEXTURE1DARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd1D, true);
     }
+    | F16TEXTURE1DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd1D, true);
+#endif
+    }
     | TEXTURE2DARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd2D, true);
     }
+    | F16TEXTURE2DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd2D, true);
+#endif
+    }
     | TEXTURECUBEARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, EsdCube, true);
     }
+    | F16TEXTURECUBEARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, EsdCube, true);
+#endif
+    }
     | ITEXTURE1D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2145,6 +2360,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, EsdRect);
     }
+    | F16TEXTURE2DRECT {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, EsdRect);
+#endif
+    }
     | ITEXTURE2DRECT {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2160,6 +2383,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, EsdBuffer);
     }
+    | F16TEXTUREBUFFER {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, EsdBuffer);
+#endif
+    }
     | ITEXTUREBUFFER {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2175,6 +2406,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd2D, false, false, true);
     }
+    | F16TEXTURE2DMS {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd2D, false, false, true);
+#endif
+    }
     | ITEXTURE2DMS {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2190,6 +2429,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setTexture(EbtFloat, Esd2D, true, false, true);
     }
+    | F16TEXTURE2DMSARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float texture", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setTexture(EbtFloat16, Esd2D, true, false, true);
+#endif
+    }
     | ITEXTURE2DMSARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2205,6 +2452,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd1D);
     }
+    | F16IMAGE1D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd1D);
+#endif
+    }
     | IIMAGE1D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2220,6 +2475,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd2D);
     }
+    | F16IMAGE2D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd2D);
+#endif
+    }
     | IIMAGE2D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2235,6 +2498,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd3D);
     }
+    | F16IMAGE3D {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd3D);
+#endif
+    }
     | IIMAGE3D {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2250,6 +2521,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, EsdRect);
     }
+    | F16IMAGE2DRECT {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, EsdRect);
+#endif
+    }
     | IIMAGE2DRECT {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2265,6 +2544,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, EsdCube);
     }
+    | F16IMAGECUBE {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, EsdCube);
+#endif
+    }
     | IIMAGECUBE {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2280,6 +2567,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, EsdBuffer);
     }
+    | F16IMAGEBUFFER {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, EsdBuffer);
+#endif
+    }
     | IIMAGEBUFFER {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2295,6 +2590,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd1D, true);
     }
+    | F16IMAGE1DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd1D, true);
+#endif
+    }
     | IIMAGE1DARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2310,6 +2613,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd2D, true);
     }
+    | F16IMAGE2DARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd2D, true);
+#endif
+    }
     | IIMAGE2DARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2325,6 +2636,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, EsdCube, true);
     }
+    | F16IMAGECUBEARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, EsdCube, true);
+#endif
+    }
     | IIMAGECUBEARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2340,6 +2659,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd2D, false, false, true);
     }
+    | F16IMAGE2DMS {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd2D, false, false, true);
+#endif
+    }
     | IIMAGE2DMS {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2355,6 +2682,14 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setImage(EbtFloat, Esd2D, true, false, true);
     }
+    | F16IMAGE2DMSARRAY {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float image", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setImage(EbtFloat16, Esd2D, true, false, true);
+#endif
+    }
     | IIMAGE2DMSARRAY {
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
         $$.basicType = EbtSampler;
@@ -2383,6 +2718,24 @@ type_specifier_nonarray
         $$.basicType = EbtSampler;
         $$.sampler.setSubpass(EbtFloat, true);
     }
+    | F16SUBPASSINPUT {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.requireStage($1.loc, EShLangFragment, "subpass input");
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setSubpass(EbtFloat16);
+#endif
+    }
+    | F16SUBPASSINPUTMS {
+#ifdef AMD_EXTENSIONS
+        parseContext.float16OpaqueCheck($1.loc, "half float subpass input", parseContext.symbolTable.atBuiltInLevel());
+        parseContext.requireStage($1.loc, EShLangFragment, "subpass input");
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtSampler;
+        $$.sampler.setSubpass(EbtFloat16, true);
+#endif
+    }
     | ISUBPASSINPUT {
         parseContext.requireStage($1.loc, EShLangFragment, "subpass input");
         $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());

Tiedoston diff-näkymää rajattu, sillä se on liian suuri
+ 486 - 389
glslang/MachineIndependent/glslang_tab.cpp


+ 195 - 151
glslang/MachineIndependent/glslang_tab.cpp.h

@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.  */
+/* A Bison parser, made by GNU Bison 3.0.4.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -197,158 +197,200 @@ extern int yydebug;
     ISAMPLER2DMSARRAY = 407,
     USAMPLER2DMSARRAY = 408,
     SAMPLEREXTERNALOES = 409,
-    SAMPLER = 410,
-    SAMPLERSHADOW = 411,
-    TEXTURE1D = 412,
-    TEXTURE2D = 413,
-    TEXTURE3D = 414,
-    TEXTURECUBE = 415,
-    TEXTURE1DARRAY = 416,
-    TEXTURE2DARRAY = 417,
-    ITEXTURE1D = 418,
-    ITEXTURE2D = 419,
-    ITEXTURE3D = 420,
-    ITEXTURECUBE = 421,
-    ITEXTURE1DARRAY = 422,
-    ITEXTURE2DARRAY = 423,
-    UTEXTURE1D = 424,
-    UTEXTURE2D = 425,
-    UTEXTURE3D = 426,
-    UTEXTURECUBE = 427,
-    UTEXTURE1DARRAY = 428,
-    UTEXTURE2DARRAY = 429,
-    TEXTURE2DRECT = 430,
-    ITEXTURE2DRECT = 431,
-    UTEXTURE2DRECT = 432,
-    TEXTUREBUFFER = 433,
-    ITEXTUREBUFFER = 434,
-    UTEXTUREBUFFER = 435,
-    TEXTURECUBEARRAY = 436,
-    ITEXTURECUBEARRAY = 437,
-    UTEXTURECUBEARRAY = 438,
-    TEXTURE2DMS = 439,
-    ITEXTURE2DMS = 440,
-    UTEXTURE2DMS = 441,
-    TEXTURE2DMSARRAY = 442,
-    ITEXTURE2DMSARRAY = 443,
-    UTEXTURE2DMSARRAY = 444,
-    SUBPASSINPUT = 445,
-    SUBPASSINPUTMS = 446,
-    ISUBPASSINPUT = 447,
-    ISUBPASSINPUTMS = 448,
-    USUBPASSINPUT = 449,
-    USUBPASSINPUTMS = 450,
-    IMAGE1D = 451,
-    IIMAGE1D = 452,
-    UIMAGE1D = 453,
-    IMAGE2D = 454,
-    IIMAGE2D = 455,
-    UIMAGE2D = 456,
-    IMAGE3D = 457,
-    IIMAGE3D = 458,
-    UIMAGE3D = 459,
-    IMAGE2DRECT = 460,
-    IIMAGE2DRECT = 461,
-    UIMAGE2DRECT = 462,
-    IMAGECUBE = 463,
-    IIMAGECUBE = 464,
-    UIMAGECUBE = 465,
-    IMAGEBUFFER = 466,
-    IIMAGEBUFFER = 467,
-    UIMAGEBUFFER = 468,
-    IMAGE1DARRAY = 469,
-    IIMAGE1DARRAY = 470,
-    UIMAGE1DARRAY = 471,
-    IMAGE2DARRAY = 472,
-    IIMAGE2DARRAY = 473,
-    UIMAGE2DARRAY = 474,
-    IMAGECUBEARRAY = 475,
-    IIMAGECUBEARRAY = 476,
-    UIMAGECUBEARRAY = 477,
-    IMAGE2DMS = 478,
-    IIMAGE2DMS = 479,
-    UIMAGE2DMS = 480,
-    IMAGE2DMSARRAY = 481,
-    IIMAGE2DMSARRAY = 482,
-    UIMAGE2DMSARRAY = 483,
-    STRUCT = 484,
-    VOID = 485,
-    WHILE = 486,
-    IDENTIFIER = 487,
-    TYPE_NAME = 488,
-    FLOATCONSTANT = 489,
-    DOUBLECONSTANT = 490,
-    INTCONSTANT = 491,
-    UINTCONSTANT = 492,
-    INT64CONSTANT = 493,
-    UINT64CONSTANT = 494,
-    INT16CONSTANT = 495,
-    UINT16CONSTANT = 496,
-    BOOLCONSTANT = 497,
-    FLOAT16CONSTANT = 498,
-    LEFT_OP = 499,
-    RIGHT_OP = 500,
-    INC_OP = 501,
-    DEC_OP = 502,
-    LE_OP = 503,
-    GE_OP = 504,
-    EQ_OP = 505,
-    NE_OP = 506,
-    AND_OP = 507,
-    OR_OP = 508,
-    XOR_OP = 509,
-    MUL_ASSIGN = 510,
-    DIV_ASSIGN = 511,
-    ADD_ASSIGN = 512,
-    MOD_ASSIGN = 513,
-    LEFT_ASSIGN = 514,
-    RIGHT_ASSIGN = 515,
-    AND_ASSIGN = 516,
-    XOR_ASSIGN = 517,
-    OR_ASSIGN = 518,
-    SUB_ASSIGN = 519,
-    LEFT_PAREN = 520,
-    RIGHT_PAREN = 521,
-    LEFT_BRACKET = 522,
-    RIGHT_BRACKET = 523,
-    LEFT_BRACE = 524,
-    RIGHT_BRACE = 525,
-    DOT = 526,
-    COMMA = 527,
-    COLON = 528,
-    EQUAL = 529,
-    SEMICOLON = 530,
-    BANG = 531,
-    DASH = 532,
-    TILDE = 533,
-    PLUS = 534,
-    STAR = 535,
-    SLASH = 536,
-    PERCENT = 537,
-    LEFT_ANGLE = 538,
-    RIGHT_ANGLE = 539,
-    VERTICAL_BAR = 540,
-    CARET = 541,
-    AMPERSAND = 542,
-    QUESTION = 543,
-    INVARIANT = 544,
-    PRECISE = 545,
-    HIGH_PRECISION = 546,
-    MEDIUM_PRECISION = 547,
-    LOW_PRECISION = 548,
-    PRECISION = 549,
-    PACKED = 550,
-    RESOURCE = 551,
-    SUPERP = 552
+    F16SAMPLER1D = 410,
+    F16SAMPLER2D = 411,
+    F16SAMPLER3D = 412,
+    F16SAMPLER2DRECT = 413,
+    F16SAMPLERCUBE = 414,
+    F16SAMPLER1DARRAY = 415,
+    F16SAMPLER2DARRAY = 416,
+    F16SAMPLERCUBEARRAY = 417,
+    F16SAMPLERBUFFER = 418,
+    F16SAMPLER2DMS = 419,
+    F16SAMPLER2DMSARRAY = 420,
+    F16SAMPLER1DSHADOW = 421,
+    F16SAMPLER2DSHADOW = 422,
+    F16SAMPLER1DARRAYSHADOW = 423,
+    F16SAMPLER2DARRAYSHADOW = 424,
+    F16SAMPLER2DRECTSHADOW = 425,
+    F16SAMPLERCUBESHADOW = 426,
+    F16SAMPLERCUBEARRAYSHADOW = 427,
+    SAMPLER = 428,
+    SAMPLERSHADOW = 429,
+    TEXTURE1D = 430,
+    TEXTURE2D = 431,
+    TEXTURE3D = 432,
+    TEXTURECUBE = 433,
+    TEXTURE1DARRAY = 434,
+    TEXTURE2DARRAY = 435,
+    ITEXTURE1D = 436,
+    ITEXTURE2D = 437,
+    ITEXTURE3D = 438,
+    ITEXTURECUBE = 439,
+    ITEXTURE1DARRAY = 440,
+    ITEXTURE2DARRAY = 441,
+    UTEXTURE1D = 442,
+    UTEXTURE2D = 443,
+    UTEXTURE3D = 444,
+    UTEXTURECUBE = 445,
+    UTEXTURE1DARRAY = 446,
+    UTEXTURE2DARRAY = 447,
+    TEXTURE2DRECT = 448,
+    ITEXTURE2DRECT = 449,
+    UTEXTURE2DRECT = 450,
+    TEXTUREBUFFER = 451,
+    ITEXTUREBUFFER = 452,
+    UTEXTUREBUFFER = 453,
+    TEXTURECUBEARRAY = 454,
+    ITEXTURECUBEARRAY = 455,
+    UTEXTURECUBEARRAY = 456,
+    TEXTURE2DMS = 457,
+    ITEXTURE2DMS = 458,
+    UTEXTURE2DMS = 459,
+    TEXTURE2DMSARRAY = 460,
+    ITEXTURE2DMSARRAY = 461,
+    UTEXTURE2DMSARRAY = 462,
+    F16TEXTURE1D = 463,
+    F16TEXTURE2D = 464,
+    F16TEXTURE3D = 465,
+    F16TEXTURE2DRECT = 466,
+    F16TEXTURECUBE = 467,
+    F16TEXTURE1DARRAY = 468,
+    F16TEXTURE2DARRAY = 469,
+    F16TEXTURECUBEARRAY = 470,
+    F16TEXTUREBUFFER = 471,
+    F16TEXTURE2DMS = 472,
+    F16TEXTURE2DMSARRAY = 473,
+    SUBPASSINPUT = 474,
+    SUBPASSINPUTMS = 475,
+    ISUBPASSINPUT = 476,
+    ISUBPASSINPUTMS = 477,
+    USUBPASSINPUT = 478,
+    USUBPASSINPUTMS = 479,
+    F16SUBPASSINPUT = 480,
+    F16SUBPASSINPUTMS = 481,
+    IMAGE1D = 482,
+    IIMAGE1D = 483,
+    UIMAGE1D = 484,
+    IMAGE2D = 485,
+    IIMAGE2D = 486,
+    UIMAGE2D = 487,
+    IMAGE3D = 488,
+    IIMAGE3D = 489,
+    UIMAGE3D = 490,
+    IMAGE2DRECT = 491,
+    IIMAGE2DRECT = 492,
+    UIMAGE2DRECT = 493,
+    IMAGECUBE = 494,
+    IIMAGECUBE = 495,
+    UIMAGECUBE = 496,
+    IMAGEBUFFER = 497,
+    IIMAGEBUFFER = 498,
+    UIMAGEBUFFER = 499,
+    IMAGE1DARRAY = 500,
+    IIMAGE1DARRAY = 501,
+    UIMAGE1DARRAY = 502,
+    IMAGE2DARRAY = 503,
+    IIMAGE2DARRAY = 504,
+    UIMAGE2DARRAY = 505,
+    IMAGECUBEARRAY = 506,
+    IIMAGECUBEARRAY = 507,
+    UIMAGECUBEARRAY = 508,
+    IMAGE2DMS = 509,
+    IIMAGE2DMS = 510,
+    UIMAGE2DMS = 511,
+    IMAGE2DMSARRAY = 512,
+    IIMAGE2DMSARRAY = 513,
+    UIMAGE2DMSARRAY = 514,
+    F16IMAGE1D = 515,
+    F16IMAGE2D = 516,
+    F16IMAGE3D = 517,
+    F16IMAGE2DRECT = 518,
+    F16IMAGECUBE = 519,
+    F16IMAGE1DARRAY = 520,
+    F16IMAGE2DARRAY = 521,
+    F16IMAGECUBEARRAY = 522,
+    F16IMAGEBUFFER = 523,
+    F16IMAGE2DMS = 524,
+    F16IMAGE2DMSARRAY = 525,
+    STRUCT = 526,
+    VOID = 527,
+    WHILE = 528,
+    IDENTIFIER = 529,
+    TYPE_NAME = 530,
+    FLOATCONSTANT = 531,
+    DOUBLECONSTANT = 532,
+    INTCONSTANT = 533,
+    UINTCONSTANT = 534,
+    INT64CONSTANT = 535,
+    UINT64CONSTANT = 536,
+    INT16CONSTANT = 537,
+    UINT16CONSTANT = 538,
+    BOOLCONSTANT = 539,
+    FLOAT16CONSTANT = 540,
+    LEFT_OP = 541,
+    RIGHT_OP = 542,
+    INC_OP = 543,
+    DEC_OP = 544,
+    LE_OP = 545,
+    GE_OP = 546,
+    EQ_OP = 547,
+    NE_OP = 548,
+    AND_OP = 549,
+    OR_OP = 550,
+    XOR_OP = 551,
+    MUL_ASSIGN = 552,
+    DIV_ASSIGN = 553,
+    ADD_ASSIGN = 554,
+    MOD_ASSIGN = 555,
+    LEFT_ASSIGN = 556,
+    RIGHT_ASSIGN = 557,
+    AND_ASSIGN = 558,
+    XOR_ASSIGN = 559,
+    OR_ASSIGN = 560,
+    SUB_ASSIGN = 561,
+    LEFT_PAREN = 562,
+    RIGHT_PAREN = 563,
+    LEFT_BRACKET = 564,
+    RIGHT_BRACKET = 565,
+    LEFT_BRACE = 566,
+    RIGHT_BRACE = 567,
+    DOT = 568,
+    COMMA = 569,
+    COLON = 570,
+    EQUAL = 571,
+    SEMICOLON = 572,
+    BANG = 573,
+    DASH = 574,
+    TILDE = 575,
+    PLUS = 576,
+    STAR = 577,
+    SLASH = 578,
+    PERCENT = 579,
+    LEFT_ANGLE = 580,
+    RIGHT_ANGLE = 581,
+    VERTICAL_BAR = 582,
+    CARET = 583,
+    AMPERSAND = 584,
+    QUESTION = 585,
+    INVARIANT = 586,
+    PRECISE = 587,
+    HIGH_PRECISION = 588,
+    MEDIUM_PRECISION = 589,
+    LOW_PRECISION = 590,
+    PRECISION = 591,
+    PACKED = 592,
+    RESOURCE = 593,
+    SUPERP = 594
   };
 #endif
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
+
 union YYSTYPE
 {
-#line 69 "MachineIndependent/glslang.y" /* yacc.c:1909  */
+#line 69 "glslang.y" /* yacc.c:1909  */
 
     struct {
         glslang::TSourceLoc loc;
@@ -383,8 +425,10 @@ union YYSTYPE
         };
     } interm;
 
-#line 387 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
+#line 429 "glslang_tab.cpp.h" /* yacc.c:1909  */
 };
+
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif
@@ -393,4 +437,4 @@ union YYSTYPE
 
 int yyparse (glslang::TParseContext* pParseContext);
 
-#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */

+ 1 - 0
glslang/MachineIndependent/parseVersions.h

@@ -80,6 +80,7 @@ public:
 #ifdef AMD_EXTENSIONS
     virtual void int16Check(const TSourceLoc& loc, const char* op, bool builtIn = false);
     virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void float16OpaqueCheck(const TSourceLoc&, const char* op, bool builtIn = false);
 #endif
     virtual void int64Check(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void spvRemoved(const TSourceLoc&, const char* op);

+ 50 - 0
glslang/MachineIndependent/reflection.cpp

@@ -415,6 +415,36 @@ public:
                 case EsdBuffer:
                     return GL_SAMPLER_BUFFER;
                 }
+#ifdef AMD_EXTENSIONS
+            case EbtFloat16:
+                switch ((int)sampler.dim) {
+                case Esd1D:
+                    switch ((int)sampler.shadow) {
+                    case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_AMD : GL_FLOAT16_SAMPLER_1D_AMD;
+                    case true:  return sampler.arrayed ? GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_1D_SHADOW_AMD;
+                    }
+                case Esd2D:
+                    switch ((int)sampler.ms) {
+                    case false:
+                        switch ((int)sampler.shadow) {
+                        case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_AMD;
+                        case true:  return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_SHADOW_AMD;
+                        }
+                    case true:      return sampler.arrayed ? GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD;
+                    }
+                case Esd3D:
+                    return GL_FLOAT16_SAMPLER_3D_AMD;
+                case EsdCube:
+                    switch ((int)sampler.shadow) {
+                    case false: return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_SAMPLER_CUBE_AMD;
+                    case true:  return sampler.arrayed ? GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD : GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD;
+                    }
+                case EsdRect:
+                    return sampler.shadow ? GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD : GL_FLOAT16_SAMPLER_2D_RECT_AMD;
+                case EsdBuffer:
+                    return GL_FLOAT16_SAMPLER_BUFFER_AMD;
+                }
+#endif
             case EbtInt:
                 switch ((int)sampler.dim) {
                 case Esd1D:
@@ -477,6 +507,26 @@ public:
                 case EsdBuffer:
                     return GL_IMAGE_BUFFER;
                 }
+#ifdef AMD_EXTENSIONS
+            case EbtFloat16:
+                switch ((int)sampler.dim) {
+                case Esd1D:
+                    return sampler.arrayed ? GL_FLOAT16_IMAGE_1D_ARRAY_AMD : GL_FLOAT16_IMAGE_1D_AMD;
+                case Esd2D:
+                    switch ((int)sampler.ms) {
+                    case false:     return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_AMD;
+                    case true:      return sampler.arrayed ? GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD : GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD;
+                    }
+                case Esd3D:
+                    return GL_FLOAT16_IMAGE_3D_AMD;
+                case EsdCube:
+                    return sampler.arrayed ? GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD : GL_FLOAT16_IMAGE_CUBE_AMD;
+                case EsdRect:
+                    return GL_FLOAT16_IMAGE_2D_RECT_AMD;
+                case EsdBuffer:
+                    return GL_FLOAT16_IMAGE_BUFFER_AMD;
+                }
+#endif
             case EbtInt:
                 switch ((int)sampler.dim) {
                 case Esd1D:

+ 1 - 0
gtests/Spv.FromFile.cpp

@@ -419,6 +419,7 @@ INSTANTIATE_TEST_CASE_P(
     Glsl, CompileVulkanToSpirvTestAMD,
     ::testing::ValuesIn(std::vector<std::string>({
         "spv.float16.frag",
+        "spv.float16Fetch.frag",
         "spv.imageLoadStoreLod.frag",
         "spv.int16.frag",
         "spv.shaderBallotAMD.comp",

Kaikkia tiedostoja ei voida näyttää, sillä liian monta tiedostoa muuttui tässä diffissä