SKIP: FAILED

<dawn>/src/tint/lang/msl/writer/printer/printer.cc:355 internal compiler error: Camera = struct @align(16) {
  projection:mat4x4<f32> @offset(0)
  inverseProjection:mat4x4<f32> @offset(64)
  view:mat4x4<f32> @offset(128)
  position:vec3<f32> @offset(192)
  time:f32 @offset(204)
  outputSize:vec2<f32> @offset(208)
  zNear:f32 @offset(216)
  zFar:f32 @offset(220)
}

ClusterLights = struct @align(4) {
  offset:u32 @offset(0)
  count:u32 @offset(4)
}

ClusterLightGroup = struct @align(4) {
  offset:u32 @offset(0)
  lights:array<ClusterLights, 27648> @offset(4)
  indices:array<u32, 1769472> @offset(221188)
}

Light = struct @align(16) {
  position:vec3<f32> @offset(0)
  range:f32 @offset(12)
  color:vec3<f32> @offset(16)
  intensity:f32 @offset(28)
}

GlobalLights = struct @align(16) {
  ambient:vec3<f32> @offset(0)
  dirColor:vec3<f32> @offset(16)
  dirIntensity:f32 @offset(28)
  dirDirection:vec3<f32> @offset(32)
  lightCount:u32 @offset(44)
  lights:array<Light> @offset(48)
}

LightShadowTable = struct @align(4) {
  light:array<i32> @offset(0)
}

ShadowProperties = struct @align(16) {
  viewport:vec4<f32> @offset(0)
  viewProj:mat4x4<f32> @offset(16)
}

LightShadows = struct @align(16) {
  properties:array<ShadowProperties> @offset(0)
}

Material = struct @align(16) {
  baseColorFactor:vec4<f32> @offset(0)
  emissiveFactor:vec3<f32> @offset(16)
  occlusionStrength:f32 @offset(28)
  metallicRoughnessFactor:vec2<f32> @offset(32)
  alphaCutoff:f32 @offset(40)
}

SurfaceInfo = struct @align(16) {
  baseColor:vec4<f32> @offset(0)
  albedo:vec3<f32> @offset(16)
  metallic:f32 @offset(28)
  roughness:f32 @offset(32)
  normal:vec3<f32> @offset(48)
  f0:vec3<f32> @offset(64)
  ao:f32 @offset(76)
  emissive:vec3<f32> @offset(80)
  v:vec3<f32> @offset(96)
}

VertexOutput = struct @align(16) {
  position:vec4<f32> @offset(0), @builtin(position)
  worldPos:vec3<f32> @offset(16), @location(0)
  view:vec3<f32> @offset(32), @location(1)
  texcoord:vec2<f32> @offset(48), @location(2)
  texcoord2:vec2<f32> @offset(56), @location(3)
  color:vec4<f32> @offset(64), @location(4)
  instanceColor:vec4<f32> @offset(80), @location(5)
  normal:vec3<f32> @offset(96), @location(6)
  tangent:vec3<f32> @offset(112), @location(7)
  bitangent:vec3<f32> @offset(128), @location(8)
}

PuctualLight = struct @align(16) {
  lightType:u32 @offset(0)
  pointToLight:vec3<f32> @offset(16)
  range:f32 @offset(28)
  color:vec3<f32> @offset(32)
  intensity:f32 @offset(44)
}

FragmentOutput = struct @align(16) {
  color:vec4<f32> @offset(0), @location(0)
  emissive:vec4<f32> @offset(16), @location(1)
}

%b1 = block {  # root
  %camera:ptr<uniform, Camera, read> = var @binding_point(0, 0)
  %clusterLights:ptr<storage, ClusterLightGroup, read> = var @binding_point(0, 1)
  %globalLights:ptr<storage, GlobalLights, read> = var @binding_point(0, 2)
  %defaultSampler:ptr<handle, sampler, read> = var @binding_point(0, 3)
  %shadowTexture:ptr<handle, texture_depth_2d, read> = var @binding_point(0, 4)
  %shadowSampler:ptr<handle, sampler_comparison, read> = var @binding_point(0, 5)
  %lightShadowTable:ptr<storage, LightShadowTable, read> = var @binding_point(0, 6)
  %shadowSampleOffsets:ptr<private, array<vec2<f32>, 16>, read_write> = var, array<vec2<f32>, 16>(vec2<f32>(-1.5f), vec2<f32>(-1.5f, -0.5f), vec2<f32>(-1.5f, 0.5f), vec2<f32>(-1.5f, 1.5f), vec2<f32>(-0.5f, -1.5f), vec2<f32>(-0.5f), vec2<f32>(-0.5f, 0.5f), vec2<f32>(-0.5f, 1.5f), vec2<f32>(0.5f, -1.5f), vec2<f32>(0.5f, -0.5f), vec2<f32>(0.5f), vec2<f32>(0.5f, 1.5f), vec2<f32>(1.5f, -1.5f), vec2<f32>(1.5f, -0.5f), vec2<f32>(1.5f, 0.5f), vec2<f32>(1.5f))
  %shadow:ptr<storage, LightShadows, read> = var @binding_point(0, 7)
  %material:ptr<uniform, Material, read> = var @binding_point(0, 8)
  %baseColorTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 9)
  %baseColorSampler:ptr<handle, sampler, read> = var @binding_point(0, 10)
  %normalTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 11)
  %normalSampler:ptr<handle, sampler, read> = var @binding_point(0, 12)
  %metallicRoughnessTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 13)
  %metallicRoughnessSampler:ptr<handle, sampler, read> = var @binding_point(0, 14)
  %occlusionTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 15)
  %occlusionSampler:ptr<handle, sampler, read> = var @binding_point(0, 16)
  %emissiveTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 17)
  %emissiveSampler:ptr<handle, sampler, read> = var @binding_point(0, 18)
  %ssaoTexture:ptr<handle, texture_2d<f32>, read> = var @binding_point(0, 19)
}

%linearTosRGB = func(%linear:vec3<f32>):vec3<f32> -> %b2 {
  %b2 = block {
    %INV_GAMMA:f32 = let 0.45454543828964233398f
    %25:vec3<f32> = construct %INV_GAMMA
    %26:vec3<f32> = pow %linear, %25
    ret %26
  }
}
%sRGBToLinear = func(%srgb:vec3<f32>):vec3<f32> -> %b3 {
  %b3 = block {
    %29:vec3<f32> = pow %srgb, vec3<f32>(2.20000004768371582031f)
    ret %29
  }
}
%linearDepth = func(%depthSample:f32):f32 -> %b4 {
  %b4 = block {
    %32:ptr<uniform, f32, read> = access %camera, 7u
    %33:f32 = load %32
    %34:ptr<uniform, f32, read> = access %camera, 6u
    %35:f32 = load %34
    %36:f32 = mul %33, %35
    %37:ptr<uniform, f32, read> = access %camera, 6u
    %38:f32 = load %37
    %39:ptr<uniform, f32, read> = access %camera, 7u
    %40:f32 = load %39
    %41:f32 = sub %38, %40
    %42:ptr<uniform, f32, read> = access %camera, 7u
    %43:f32 = load %42
    %44:f32 = fma %depthSample, %41, %43
    %45:f32 = div %36, %44
    ret %45
  }
}
%getTile = func(%fragCoord:vec4<f32>):vec3<u32> -> %b5 {
  %b5 = block {
    %48:ptr<uniform, f32, read> = access %camera, 7u
    %49:f32 = load %48
    %50:ptr<uniform, f32, read> = access %camera, 6u
    %51:f32 = load %50
    %52:f32 = div %49, %51
    %53:f32 = log2 %52
    %sliceScale:f32 = div 48.0f, %53
    %55:ptr<uniform, f32, read> = access %camera, 6u
    %56:f32 = load %55
    %57:f32 = log2 %56
    %58:f32 = mul 48.0f, %57
    %59:ptr<uniform, f32, read> = access %camera, 7u
    %60:f32 = load %59
    %61:ptr<uniform, f32, read> = access %camera, 6u
    %62:f32 = load %61
    %63:f32 = div %60, %62
    %64:f32 = log2 %63
    %65:f32 = div %58, %64
    %sliceBias:f32 = negation %65
    %67:f32 = access %fragCoord, 2u
    %68:f32 = call %linearDepth, %67
    %69:f32 = log2 %68
    %70:f32 = mul %69, %sliceScale
    %71:f32 = add %70, %sliceBias
    %72:f32 = max %71, 0.0f
    %zTile:u32 = convert %72
    %74:f32 = access %fragCoord, 0u
    %75:ptr<uniform, vec2<f32>, read> = access %camera, 5u
    %76:f32 = load_vector_element %75, 0u
    %77:f32 = div %76, 32.0f
    %78:f32 = div %74, %77
    %79:u32 = convert %78
    %80:f32 = access %fragCoord, 1u
    %81:ptr<uniform, vec2<f32>, read> = access %camera, 5u
    %82:f32 = load_vector_element %81, 1u
    %83:f32 = div %82, 18.0f
    %84:f32 = div %80, %83
    %85:u32 = convert %84
    %86:vec3<u32> = construct %79, %85, %zTile
    ret %86
  }
}
%getClusterIndex = func(%fragCoord_1:vec4<f32>):u32 -> %b6 {  # %fragCoord_1: 'fragCoord'
  %b6 = block {
    %tile:vec3<u32> = call %getTile, %fragCoord_1
    %90:u32 = access %tile, 0u
    %91:u32 = access %tile, 1u
    %92:u32 = mul %91, 32u
    %93:u32 = add %90, %92
    %94:u32 = access %tile, 2u
    %95:u32 = mul %94, 32u
    %96:u32 = mul %95, 18u
    %97:u32 = add %93, %96
    ret %97
  }
}
%dirLightVisibility = func(%worldPos:vec3<f32>):f32 -> %b7 {
  %b7 = block {
    %100:ptr<storage, i32, read> = access %lightShadowTable, 0u, 0u
    %shadowIndex:i32 = load %100
    %102:bool = eq %shadowIndex, -1i
    if %102 [t: %b8] {  # if_1
      %b8 = block {  # true
        ret 1.0f
      }
    }
    %103:ptr<storage, vec4<f32>, read> = access %shadow, 0u, %shadowIndex, 0u
    %viewport:vec4<f32> = load %103
    %105:ptr<storage, mat4x4<f32>, read> = access %shadow, 0u, %shadowIndex, 1u
    %106:mat4x4<f32> = load %105
    %107:vec4<f32> = construct %worldPos, 1.0f
    %lightPos:vec4<f32> = mul %106, %107
    %109:vec2<f32> = swizzle %lightPos, xy
    %110:f32 = access %lightPos, 3u
    %111:vec2<f32> = div %109, %110
    %112:vec2<f32> = mul %111, vec2<f32>(0.5f, -0.5f)
    %113:vec2<f32> = add %112, vec2<f32>(0.5f)
    %114:f32 = access %lightPos, 2u
    %115:f32 = access %lightPos, 3u
    %116:f32 = div %114, %115
    %shadowPos:vec3<f32> = construct %113, %116
    %118:vec2<f32> = swizzle %viewport, xy
    %119:vec2<f32> = swizzle %shadowPos, xy
    %120:vec2<f32> = swizzle %viewport, zw
    %121:vec2<f32> = mul %119, %120
    %122:vec2<f32> = add %118, %121
    %viewportPos:vec2<f32> = construct %122
    %124:texture_depth_2d = load %shadowTexture
    %125:vec2<u32> = textureDimensions %124, 0i
    %126:vec2<f32> = convert %125
    %texelSize:vec2<f32> = div 1.0f, %126
    %128:vec2<f32> = swizzle %viewport, xy
    %129:vec2<f32> = sub %128, %texelSize
    %130:vec2<f32> = swizzle %viewport, xy
    %131:vec2<f32> = swizzle %viewport, zw
    %132:vec2<f32> = add %130, %131
    %133:vec2<f32> = add %132, %texelSize
    %clampRect:vec4<f32> = construct %129, %133
    %visibility:ptr<function, f32, read_write> = var, 0.0f
    loop [i: %b9, b: %b10, c: %b11] {  # loop_1
      %b9 = block {  # initializer
        %i:ptr<function, u32, read_write> = var, 0u
        next_iteration %b10
      }
      %b10 = block {  # body
        %137:u32 = load %i
        %138:bool = lt %137, 16u
        if %138 [t: %b12, f: %b13] {  # if_2
          %b12 = block {  # true
            exit_if  # if_2
          }
          %b13 = block {  # false
            exit_loop  # loop_1
          }
        }
        %139:f32 = load %visibility
        %140:texture_depth_2d = load %shadowTexture
        %141:sampler_comparison = load %shadowSampler
        %142:u32 = load %i
        %143:ptr<private, vec2<f32>, read_write> = access %shadowSampleOffsets, %142
        %144:vec2<f32> = load %143
        %145:vec2<f32> = mul %144, %texelSize
        %146:vec2<f32> = add %viewportPos, %145
        %147:vec2<f32> = swizzle %clampRect, xy
        %148:vec2<f32> = swizzle %clampRect, zw
        %149:vec2<f32> = clamp %146, %147, %148
        %150:f32 = access %shadowPos, 2u
        %151:f32 = sub %150, 0.00300000002607703209f
        %152:f32 = textureSampleCompareLevel %140, %141, %149, %151
        %153:f32 = add %139, %152
        store %visibility, %153
        continue %b11
      }
      %b11 = block {  # continuing
        %154:u32 = load %i
        %155:u32 = add %154, 1u
        store %i, %155
        next_iteration %b10
      }
    }
    %156:f32 = load %visibility
    %157:f32 = div %156, 16.0f
    ret %157
  }
}
%getCubeFace = func(%v:vec3<f32>):i32 -> %b14 {
  %b14 = block {
    %vAbs:vec3<f32> = abs %v
    %161:f32 = access %vAbs, 2u
    %162:f32 = access %vAbs, 0u
    %163:bool = gte %161, %162
    %164:bool = if %163 [t: %b15, f: %b16] {  # if_3
      %b15 = block {  # true
        %165:f32 = access %vAbs, 2u
        %166:f32 = access %vAbs, 1u
        %167:bool = gte %165, %166
        exit_if %167  # if_3
      }
      %b16 = block {  # false
        exit_if false  # if_3
      }
    }
    if %164 [t: %b17] {  # if_4
      %b17 = block {  # true
        %168:f32 = access %v, 2u
        %169:bool = lt %168, 0.0f
        if %169 [t: %b18] {  # if_5
          %b18 = block {  # true
            ret 5i
          }
        }
        ret 4i
      }
    }
    %170:f32 = access %vAbs, 1u
    %171:f32 = access %vAbs, 0u
    %172:bool = gte %170, %171
    if %172 [t: %b19] {  # if_6
      %b19 = block {  # true
        %173:f32 = access %v, 1u
        %174:bool = lt %173, 0.0f
        if %174 [t: %b20] {  # if_7
          %b20 = block {  # true
            ret 3i
          }
        }
        ret 2i
      }
    }
    %175:f32 = access %v, 0u
    %176:bool = lt %175, 0.0f
    if %176 [t: %b21] {  # if_8
      %b21 = block {  # true
        ret 1i
      }
    }
    ret 0i
  }
}
%pointLightVisibility = func(%lightIndex:u32, %worldPos_1:vec3<f32>, %pointToLight:vec3<f32>):f32 -> %b22 {  # %worldPos_1: 'worldPos'
  %b22 = block {
    %181:u32 = add %lightIndex, 1u
    %182:ptr<storage, i32, read> = access %lightShadowTable, 0u, %181
    %183:i32 = load %182
    %shadowIndex_1:ptr<function, i32, read_write> = var, %183  # %shadowIndex_1: 'shadowIndex'
    %185:i32 = load %shadowIndex_1
    %186:bool = eq %185, -1i
    if %186 [t: %b23] {  # if_9
      %b23 = block {  # true
        ret 1.0f
      }
    }
    %187:i32 = load %shadowIndex_1
    %188:vec3<f32> = mul %pointToLight, -1.0f
    %189:i32 = call %getCubeFace, %188
    %190:i32 = add %187, %189
    store %shadowIndex_1, %190
    %191:i32 = load %shadowIndex_1
    %192:ptr<storage, vec4<f32>, read> = access %shadow, 0u, %191, 0u
    %viewport_1:vec4<f32> = load %192  # %viewport_1: 'viewport'
    %194:i32 = load %shadowIndex_1
    %195:ptr<storage, mat4x4<f32>, read> = access %shadow, 0u, %194, 1u
    %196:mat4x4<f32> = load %195
    %197:vec4<f32> = construct %worldPos_1, 1.0f
    %lightPos_1:vec4<f32> = mul %196, %197  # %lightPos_1: 'lightPos'
    %199:vec2<f32> = swizzle %lightPos_1, xy
    %200:f32 = access %lightPos_1, 3u
    %201:vec2<f32> = div %199, %200
    %202:vec2<f32> = mul %201, vec2<f32>(0.5f, -0.5f)
    %203:vec2<f32> = add %202, vec2<f32>(0.5f)
    %204:f32 = access %lightPos_1, 2u
    %205:f32 = access %lightPos_1, 3u
    %206:f32 = div %204, %205
    %shadowPos_1:vec3<f32> = construct %203, %206  # %shadowPos_1: 'shadowPos'
    %208:vec2<f32> = swizzle %viewport_1, xy
    %209:vec2<f32> = swizzle %shadowPos_1, xy
    %210:vec2<f32> = swizzle %viewport_1, zw
    %211:vec2<f32> = mul %209, %210
    %212:vec2<f32> = add %208, %211
    %viewportPos_1:vec2<f32> = construct %212  # %viewportPos_1: 'viewportPos'
    %214:texture_depth_2d = load %shadowTexture
    %215:vec2<u32> = textureDimensions %214, 0i
    %216:vec2<f32> = convert %215
    %texelSize_1:vec2<f32> = div 1.0f, %216  # %texelSize_1: 'texelSize'
    %218:vec2<f32> = swizzle %viewport_1, xy
    %219:vec2<f32> = swizzle %viewport_1, xy
    %220:vec2<f32> = swizzle %viewport_1, zw
    %221:vec2<f32> = add %219, %220
    %clampRect_1:vec4<f32> = construct %218, %221  # %clampRect_1: 'clampRect'
    %visibility_1:ptr<function, f32, read_write> = var, 0.0f  # %visibility_1: 'visibility'
    loop [i: %b24, b: %b25, c: %b26] {  # loop_2
      %b24 = block {  # initializer
        %i_1:ptr<function, u32, read_write> = var, 0u  # %i_1: 'i'
        next_iteration %b25
      }
      %b25 = block {  # body
        %225:u32 = load %i_1
        %226:bool = lt %225, 16u
        if %226 [t: %b27, f: %b28] {  # if_10
          %b27 = block {  # true
            exit_if  # if_10
          }
          %b28 = block {  # false
            exit_loop  # loop_2
          }
        }
        %227:f32 = load %visibility_1
        %228:texture_depth_2d = load %shadowTexture
        %229:sampler_comparison = load %shadowSampler
        %230:u32 = load %i_1
        %231:ptr<private, vec2<f32>, read_write> = access %shadowSampleOffsets, %230
        %232:vec2<f32> = load %231
        %233:vec2<f32> = mul %232, %texelSize_1
        %234:vec2<f32> = add %viewportPos_1, %233
        %235:vec2<f32> = swizzle %clampRect_1, xy
        %236:vec2<f32> = swizzle %clampRect_1, zw
        %237:vec2<f32> = clamp %234, %235, %236
        %238:f32 = access %shadowPos_1, 2u
        %239:f32 = sub %238, 0.00999999977648258209f
        %240:f32 = textureSampleCompareLevel %228, %229, %237, %239
        %241:f32 = add %227, %240
        store %visibility_1, %241
        continue %b26
      }
      %b26 = block {  # continuing
        %242:u32 = load %i_1
        %243:u32 = add %242, 1u
        store %i_1, %243
        next_iteration %b25
      }
    }
    %244:f32 = load %visibility_1
    %245:f32 = div %244, 16.0f
    ret %245
  }
}
%GetSurfaceInfo = func(%input:VertexOutput):SurfaceInfo -> %b29 {
  %b29 = block {
    %surface:ptr<function, SurfaceInfo, read_write> = var
    %249:ptr<function, vec3<f32>, read_write> = access %surface, 8u
    %250:vec3<f32> = access %input, 2u
    %251:vec3<f32> = normalize %250
    store %249, %251
    %252:vec3<f32> = access %input, 8u
    %253:vec3<f32> = access %input, 9u
    %254:vec3<f32> = access %input, 7u
    %tbn:mat3x3<f32> = construct %252, %253, %254
    %256:texture_2d<f32> = load %normalTexture
    %257:sampler = load %normalSampler
    %258:vec2<f32> = access %input, 3u
    %259:vec4<f32> = textureSample %256, %257, %258
    %normalMap:vec3<f32> = swizzle %259, xyz
    %261:ptr<function, vec3<f32>, read_write> = access %surface, 4u
    %262:vec3<f32> = mul 2.0f, %normalMap
    %263:vec3<f32> = sub %262, vec3<f32>(1.0f)
    %264:vec3<f32> = mul %tbn, %263
    %265:vec3<f32> = normalize %264
    store %261, %265
    %266:texture_2d<f32> = load %baseColorTexture
    %267:sampler = load %baseColorSampler
    %268:vec2<f32> = access %input, 3u
    %baseColorMap:vec4<f32> = textureSample %266, %267, %268
    %270:ptr<function, vec4<f32>, read_write> = access %surface, 0u
    %271:vec4<f32> = access %input, 5u
    %272:ptr<uniform, vec4<f32>, read> = access %material, 0u
    %273:vec4<f32> = load %272
    %274:vec4<f32> = mul %271, %273
    %275:vec4<f32> = mul %274, %baseColorMap
    store %270, %275
    %276:ptr<function, vec4<f32>, read_write> = access %surface, 0u
    %277:f32 = load_vector_element %276, 3u
    %278:ptr<uniform, f32, read> = access %material, 4u
    %279:f32 = load %278
    %280:bool = lt %277, %279
    if %280 [t: %b30] {  # if_11
      %b30 = block {  # true
        exit_if  # if_11
      }
    }
    %281:ptr<function, vec3<f32>, read_write> = access %surface, 1u
    %282:ptr<function, vec4<f32>, read_write> = access %surface, 0u
    %283:vec4<f32> = load %282
    %284:vec3<f32> = swizzle %283, xyz
    store %281, %284
    %285:texture_2d<f32> = load %metallicRoughnessTexture
    %286:sampler = load %metallicRoughnessSampler
    %287:vec2<f32> = access %input, 3u
    %metallicRoughnessMap:vec4<f32> = textureSample %285, %286, %287
    %289:ptr<function, f32, read_write> = access %surface, 2u
    %290:ptr<uniform, vec2<f32>, read> = access %material, 3u
    %291:f32 = load_vector_element %290, 0u
    %292:f32 = access %metallicRoughnessMap, 2u
    %293:f32 = mul %291, %292
    store %289, %293
    %294:ptr<function, f32, read_write> = access %surface, 3u
    %295:ptr<uniform, vec2<f32>, read> = access %material, 3u
    %296:f32 = load_vector_element %295, 1u
    %297:f32 = access %metallicRoughnessMap, 1u
    %298:f32 = mul %296, %297
    store %294, %298
    %dielectricSpec:vec3<f32> = let vec3<f32>(0.03999999910593032837f)
    %300:ptr<function, vec3<f32>, read_write> = access %surface, 5u
    %301:ptr<function, vec3<f32>, read_write> = access %surface, 1u
    %302:vec3<f32> = load %301
    %303:ptr<function, f32, read_write> = access %surface, 2u
    %304:f32 = load %303
    %305:vec3<f32> = construct %304
    %306:vec3<f32> = mix %dielectricSpec, %302, %305
    store %300, %306
    %307:texture_2d<f32> = load %occlusionTexture
    %308:sampler = load %occlusionSampler
    %309:vec2<f32> = access %input, 3u
    %occlusionMap:vec4<f32> = textureSample %307, %308, %309
    %311:ptr<function, f32, read_write> = access %surface, 6u
    %312:ptr<uniform, f32, read> = access %material, 2u
    %313:f32 = load %312
    %314:f32 = access %occlusionMap, 0u
    %315:f32 = mul %313, %314
    store %311, %315
    %316:texture_2d<f32> = load %emissiveTexture
    %317:sampler = load %emissiveSampler
    %318:vec2<f32> = access %input, 3u
    %emissiveMap:vec4<f32> = textureSample %316, %317, %318
    %320:ptr<function, vec3<f32>, read_write> = access %surface, 7u
    %321:ptr<uniform, vec3<f32>, read> = access %material, 1u
    %322:vec3<f32> = load %321
    %323:vec3<f32> = swizzle %emissiveMap, xyz
    %324:vec3<f32> = mul %322, %323
    store %320, %324
    %325:f32 = access %input, 6u, 3u
    %326:bool = eq %325, 0.0f
    if %326 [t: %b31, f: %b32] {  # if_12
      %b31 = block {  # true
        %327:ptr<function, vec3<f32>, read_write> = access %surface, 1u
        %328:ptr<function, vec3<f32>, read_write> = access %surface, 1u
        %329:vec3<f32> = load %328
        %330:vec4<f32> = access %input, 6u
        %331:vec3<f32> = swizzle %330, xyz
        %332:vec3<f32> = add %329, %331
        store %327, %332
        exit_if  # if_12
      }
      %b32 = block {  # false
        %333:ptr<function, vec3<f32>, read_write> = access %surface, 1u
        %334:ptr<function, vec3<f32>, read_write> = access %surface, 1u
        %335:vec3<f32> = load %334
        %336:vec4<f32> = access %input, 6u
        %337:vec3<f32> = swizzle %336, xyz
        %338:vec3<f32> = mul %335, %337
        store %333, %338
        exit_if  # if_12
      }
    }
    %339:SurfaceInfo = load %surface
    ret %339
  }
}
%FresnelSchlick = func(%cosTheta:f32, %F0:vec3<f32>):vec3<f32> -> %b33 {
  %b33 = block {
    %343:vec3<f32> = sub vec3<f32>(1.0f), %F0
    %344:f32 = sub 1.0f, %cosTheta
    %345:f32 = pow %344, 5.0f
    %346:vec3<f32> = mul %343, %345
    %347:vec3<f32> = add %F0, %346
    ret %347
  }
}
%DistributionGGX = func(%N:vec3<f32>, %H:vec3<f32>, %roughness:f32):f32 -> %b34 {
  %b34 = block {
    %a:f32 = mul %roughness, %roughness
    %a2:f32 = mul %a, %a
    %354:f32 = dot %N, %H
    %NdotH:f32 = max %354, 0.0f
    %NdotH2:f32 = mul %NdotH, %NdotH
    %num:f32 = let %a2
    %358:f32 = sub %a2, 1.0f
    %359:f32 = mul %NdotH2, %358
    %denom:f32 = add %359, 1.0f
    %361:f32 = mul 3.14159274101257324219f, %denom
    %362:f32 = mul %361, %denom
    %363:f32 = div %num, %362
    ret %363
  }
}
%GeometrySchlickGGX = func(%NdotV:f32, %roughness_1:f32):f32 -> %b35 {  # %roughness_1: 'roughness'
  %b35 = block {
    %r:f32 = add %roughness_1, 1.0f
    %368:f32 = mul %r, %r
    %k:f32 = div %368, 8.0f
    %num_1:f32 = let %NdotV  # %num_1: 'num'
    %371:f32 = sub 1.0f, %k
    %372:f32 = mul %NdotV, %371
    %denom_1:f32 = add %372, %k  # %denom_1: 'denom'
    %374:f32 = div %num_1, %denom_1
    ret %374
  }
}
%GeometrySmith = func(%N_1:vec3<f32>, %V:vec3<f32>, %L:vec3<f32>, %roughness_2:f32):f32 -> %b36 {  # %N_1: 'N', %roughness_2: 'roughness'
  %b36 = block {
    %380:f32 = dot %N_1, %V
    %NdotV_1:f32 = max %380, 0.0f  # %NdotV_1: 'NdotV'
    %382:f32 = dot %N_1, %L
    %NdotL:f32 = max %382, 0.0f
    %ggx2:f32 = call %GeometrySchlickGGX, %NdotV_1, %roughness_2
    %ggx1:f32 = call %GeometrySchlickGGX, %NdotL, %roughness_2
    %386:f32 = mul %ggx1, %ggx2
    ret %386
  }
}
%lightAttenuation = func(%light:PuctualLight):f32 -> %b37 {
  %b37 = block {
    %389:u32 = access %light, 0u
    %390:bool = eq %389, 2u
    if %390 [t: %b38] {  # if_13
      %b38 = block {  # true
        ret 1.0f
      }
    }
    %391:vec3<f32> = access %light, 1u
    %distance:f32 = length %391
    %393:f32 = access %light, 2u
    %394:bool = lte %393, 0.0f
    if %394 [t: %b39] {  # if_14
      %b39 = block {  # true
        %395:f32 = pow %distance, 2.0f
        %396:f32 = div 1.0f, %395
        ret %396
      }
    }
    %397:f32 = access %light, 2u
    %398:f32 = div %distance, %397
    %399:f32 = pow %398, 4.0f
    %400:f32 = sub 1.0f, %399
    %401:f32 = clamp %400, 0.0f, 1.0f
    %402:f32 = pow %distance, 2.0f
    %403:f32 = div %401, %402
    ret %403
  }
}
%lightRadiance = func(%light_1:PuctualLight, %surface_1:SurfaceInfo):vec3<f32> -> %b40 {  # %light_1: 'light', %surface_1: 'surface'
  %b40 = block {
    %407:vec3<f32> = access %light_1, 1u
    %L_1:vec3<f32> = normalize %407  # %L_1: 'L'
    %409:vec3<f32> = access %surface_1, 8u
    %410:vec3<f32> = add %409, %L_1
    %H_1:vec3<f32> = normalize %410  # %H_1: 'H'
    %412:vec3<f32> = access %surface_1, 4u
    %413:f32 = access %surface_1, 3u
    %NDF:f32 = call %DistributionGGX, %412, %H_1, %413
    %415:vec3<f32> = access %surface_1, 4u
    %416:vec3<f32> = access %surface_1, 8u
    %417:f32 = access %surface_1, 3u
    %G:f32 = call %GeometrySmith, %415, %416, %L_1, %417
    %419:vec3<f32> = access %surface_1, 8u
    %420:f32 = dot %H_1, %419
    %421:f32 = max %420, 0.0f
    %422:vec3<f32> = access %surface_1, 5u
    %F:vec3<f32> = call %FresnelSchlick, %421, %422
    %424:vec3<f32> = sub vec3<f32>(1.0f), %F
    %425:f32 = access %surface_1, 2u
    %426:f32 = sub 1.0f, %425
    %kD:vec3<f32> = mul %424, %426
    %428:vec3<f32> = access %surface_1, 4u
    %429:f32 = dot %428, %L_1
    %NdotL_1:f32 = max %429, 0.0f  # %NdotL_1: 'NdotL'
    %431:f32 = mul %NDF, %G
    %numerator:vec3<f32> = mul %431, %F
    %433:vec3<f32> = access %surface_1, 4u
    %434:vec3<f32> = access %surface_1, 8u
    %435:f32 = dot %433, %434
    %436:f32 = max %435, 0.0f
    %437:f32 = mul 4.0f, %436
    %438:f32 = mul %437, %NdotL_1
    %denominator:f32 = max %438, 0.00100000004749745131f
    %440:vec3<f32> = construct %denominator
    %specular:vec3<f32> = div %numerator, %440
    %442:vec3<f32> = access %light_1, 3u
    %443:f32 = access %light_1, 4u
    %444:vec3<f32> = mul %442, %443
    %445:f32 = call %lightAttenuation, %light_1
    %radiance:vec3<f32> = mul %444, %445
    %447:vec3<f32> = access %surface_1, 1u
    %448:vec3<f32> = mul %kD, %447
    %449:vec3<f32> = div %448, vec3<f32>(3.14159274101257324219f)
    %450:vec3<f32> = add %449, %specular
    %451:vec3<f32> = mul %450, %radiance
    %452:vec3<f32> = mul %451, %NdotL_1
    ret %452
  }
}
%fragmentMain = @fragment func(%input_1:VertexOutput):FragmentOutput -> %b41 {  # %input_1: 'input'
  %b41 = block {
    %surface_2:SurfaceInfo = call %GetSurfaceInfo, %input_1  # %surface_2: 'surface'
    %Lo:ptr<function, vec3<f32>, read_write> = var, vec3<f32>(0.0f)
    %457:ptr<storage, f32, read> = access %globalLights, 2u
    %458:f32 = load %457
    %459:bool = gt %458, 0.0f
    if %459 [t: %b42] {  # if_15
      %b42 = block {  # true
        %light_2:ptr<function, PuctualLight, read_write> = var  # %light_2: 'light'
        %461:ptr<function, u32, read_write> = access %light_2, 0u
        store %461, 2u
        %462:ptr<function, vec3<f32>, read_write> = access %light_2, 1u
        %463:ptr<storage, vec3<f32>, read> = access %globalLights, 3u
        %464:vec3<f32> = load %463
        store %462, %464
        %465:ptr<function, vec3<f32>, read_write> = access %light_2, 3u
        %466:ptr<storage, vec3<f32>, read> = access %globalLights, 1u
        %467:vec3<f32> = load %466
        store %465, %467
        %468:ptr<function, f32, read_write> = access %light_2, 4u
        %469:ptr<storage, f32, read> = access %globalLights, 2u
        %470:f32 = load %469
        store %468, %470
        %471:vec3<f32> = access %input_1, 1u
        %lightVis:f32 = call %dirLightVisibility, %471
        %473:vec3<f32> = load %Lo
        %474:PuctualLight = load %light_2
        %475:vec3<f32> = call %lightRadiance, %474, %surface_2
        %476:vec3<f32> = mul %475, %lightVis
        %477:vec3<f32> = add %473, %476
        store %Lo, %477
        exit_if  # if_15
      }
    }
    %478:vec4<f32> = access %input_1, 0u
    %clusterIndex:u32 = call %getClusterIndex, %478
    %480:ptr<storage, u32, read> = access %clusterLights, 1u, %clusterIndex, 0u
    %lightOffset:u32 = load %480
    %482:ptr<storage, u32, read> = access %clusterLights, 1u, %clusterIndex, 1u
    %lightCount:u32 = load %482
    loop [i: %b43, b: %b44, c: %b45] {  # loop_3
      %b43 = block {  # initializer
        %lightIndex_1:ptr<function, u32, read_write> = var, 0u  # %lightIndex_1: 'lightIndex'
        next_iteration %b44
      }
      %b44 = block {  # body
        %485:u32 = load %lightIndex_1
        %486:bool = lt %485, %lightCount
        if %486 [t: %b46, f: %b47] {  # if_16
          %b46 = block {  # true
            exit_if  # if_16
          }
          %b47 = block {  # false
            exit_loop  # loop_3
          }
        }
        %487:u32 = load %lightIndex_1
        %488:u32 = add %lightOffset, %487
        %489:ptr<storage, u32, read> = access %clusterLights, 2u, %488
        %i_2:u32 = load %489  # %i_2: 'i'
        %light_3:ptr<function, PuctualLight, read_write> = var  # %light_3: 'light'
        %492:ptr<function, u32, read_write> = access %light_3, 0u
        store %492, 0u
        %493:ptr<function, vec3<f32>, read_write> = access %light_3, 1u
        %494:ptr<storage, vec3<f32>, read> = access %globalLights, 5u, %i_2, 0u
        %495:vec3<f32> = load %494
        %496:vec3<f32> = swizzle %495, xyz
        %497:vec3<f32> = access %input_1, 1u
        %498:vec3<f32> = sub %496, %497
        store %493, %498
        %499:ptr<function, f32, read_write> = access %light_3, 2u
        %500:ptr<storage, f32, read> = access %globalLights, 5u, %i_2, 1u
        %501:f32 = load %500
        store %499, %501
        %502:ptr<function, vec3<f32>, read_write> = access %light_3, 3u
        %503:ptr<storage, vec3<f32>, read> = access %globalLights, 5u, %i_2, 2u
        %504:vec3<f32> = load %503
        store %502, %504
        %505:ptr<function, f32, read_write> = access %light_3, 4u
        %506:ptr<storage, f32, read> = access %globalLights, 5u, %i_2, 3u
        %507:f32 = load %506
        store %505, %507
        %508:vec3<f32> = access %input_1, 1u
        %509:ptr<function, vec3<f32>, read_write> = access %light_3, 1u
        %510:vec3<f32> = load %509
        %lightVis_1:f32 = call %pointLightVisibility, %i_2, %508, %510  # %lightVis_1: 'lightVis'
        %512:vec3<f32> = load %Lo
        %513:PuctualLight = load %light_3
        %514:vec3<f32> = call %lightRadiance, %513, %surface_2
        %515:vec3<f32> = mul %514, %lightVis_1
        %516:vec3<f32> = add %512, %515
        store %Lo, %516
        continue %b45
      }
      %b45 = block {  # continuing
        %517:u32 = load %lightIndex_1
        %518:u32 = add %517, 1u
        store %lightIndex_1, %518
        next_iteration %b44
      }
    }
    %519:vec4<f32> = access %input_1, 0u
    %520:vec2<f32> = swizzle %519, xy
    %521:texture_2d<f32> = load %ssaoTexture
    %522:vec2<u32> = textureDimensions %521
    %523:vec2<u32> = swizzle %522, xy
    %524:vec2<f32> = convert %523
    %ssaoCoord:vec2<f32> = div %520, %524
    %526:texture_2d<f32> = load %ssaoTexture
    %527:sampler = load %defaultSampler
    %528:vec4<f32> = textureSample %526, %527, %ssaoCoord
    %ssaoFactor:f32 = access %528, 0u
    %530:ptr<storage, vec3<f32>, read> = access %globalLights, 0u
    %531:vec3<f32> = load %530
    %532:vec3<f32> = access %surface_2, 1u
    %533:vec3<f32> = mul %531, %532
    %534:f32 = access %surface_2, 6u
    %535:vec3<f32> = mul %533, %534
    %ambient:vec3<f32> = mul %535, %ssaoFactor
    %537:vec3<f32> = load %Lo
    %538:vec3<f32> = add %537, %ambient
    %539:vec3<f32> = access %surface_2, 7u
    %540:vec3<f32> = add %538, %539
    %color:vec3<f32> = call %linearTosRGB, %540
    %out:ptr<function, FragmentOutput, read_write> = var
    %543:ptr<function, vec4<f32>, read_write> = access %out, 0u
    %544:f32 = access %surface_2, 0u, 3u
    %545:vec4<f32> = construct %color, %544
    store %543, %545
    %546:ptr<function, vec4<f32>, read_write> = access %out, 1u
    %547:vec3<f32> = access %surface_2, 7u
    %548:f32 = access %surface_2, 0u, 3u
    %549:vec4<f32> = construct %547, %548
    store %546, %549
    %550:FragmentOutput = load %out
    ret %550
  }
}

unhandled variable address space
********************************************************************
*  The tint shader compiler has encountered an unexpected error.   *
*                                                                  *
*  Please help us fix this issue by submitting a bug report at     *
*  crbug.com/tint with the source program that triggered the bug.  *
********************************************************************