SKIP: FAILED

../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: S = struct @align(16) {
  v:vec3<f32> @offset(0)
}

$B1: {  # root
  %U:ptr<uniform, S, read> = var @binding_point(0, 0)
}

%f = func():void {
  $B2: {
    %3:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %4:vec3<f32> = load %3
    %v:ptr<function, vec3<f32>, read_write> = var, %4
    %6:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %7:f32 = load_vector_element %6, 0u
    %x:ptr<function, f32, read_write> = var, %7
    %9:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %10:f32 = load_vector_element %9, 1u
    %y:ptr<function, f32, read_write> = var, %10
    %12:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %13:f32 = load_vector_element %12, 2u
    %z:ptr<function, f32, read_write> = var, %13
    %15:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %16:vec3<f32> = load %15
    %17:vec2<f32> = swizzle %16, xx
    %xx:ptr<function, vec2<f32>, read_write> = var, %17
    %19:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %20:vec3<f32> = load %19
    %21:vec2<f32> = swizzle %20, xy
    %xy:ptr<function, vec2<f32>, read_write> = var, %21
    %23:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %24:vec3<f32> = load %23
    %25:vec2<f32> = swizzle %24, xz
    %xz:ptr<function, vec2<f32>, read_write> = var, %25
    %27:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %28:vec3<f32> = load %27
    %29:vec2<f32> = swizzle %28, yx
    %yx:ptr<function, vec2<f32>, read_write> = var, %29
    %31:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %32:vec3<f32> = load %31
    %33:vec2<f32> = swizzle %32, yy
    %yy:ptr<function, vec2<f32>, read_write> = var, %33
    %35:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %36:vec3<f32> = load %35
    %37:vec2<f32> = swizzle %36, yz
    %yz:ptr<function, vec2<f32>, read_write> = var, %37
    %39:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %40:vec3<f32> = load %39
    %41:vec2<f32> = swizzle %40, zx
    %zx:ptr<function, vec2<f32>, read_write> = var, %41
    %43:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %44:vec3<f32> = load %43
    %45:vec2<f32> = swizzle %44, zy
    %zy:ptr<function, vec2<f32>, read_write> = var, %45
    %47:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %48:vec3<f32> = load %47
    %49:vec2<f32> = swizzle %48, zz
    %zz:ptr<function, vec2<f32>, read_write> = var, %49
    %51:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %52:vec3<f32> = load %51
    %53:vec3<f32> = swizzle %52, xxx
    %xxx:ptr<function, vec3<f32>, read_write> = var, %53
    %55:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %56:vec3<f32> = load %55
    %57:vec3<f32> = swizzle %56, xxy
    %xxy:ptr<function, vec3<f32>, read_write> = var, %57
    %59:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %60:vec3<f32> = load %59
    %61:vec3<f32> = swizzle %60, xxz
    %xxz:ptr<function, vec3<f32>, read_write> = var, %61
    %63:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %64:vec3<f32> = load %63
    %65:vec3<f32> = swizzle %64, xyx
    %xyx:ptr<function, vec3<f32>, read_write> = var, %65
    %67:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %68:vec3<f32> = load %67
    %69:vec3<f32> = swizzle %68, xyy
    %xyy:ptr<function, vec3<f32>, read_write> = var, %69
    %71:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %72:vec3<f32> = load %71
    %73:vec3<f32> = swizzle %72, xyz
    %xyz:ptr<function, vec3<f32>, read_write> = var, %73
    %75:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %76:vec3<f32> = load %75
    %77:vec3<f32> = swizzle %76, xzx
    %xzx:ptr<function, vec3<f32>, read_write> = var, %77
    %79:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %80:vec3<f32> = load %79
    %81:vec3<f32> = swizzle %80, xzy
    %xzy:ptr<function, vec3<f32>, read_write> = var, %81
    %83:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %84:vec3<f32> = load %83
    %85:vec3<f32> = swizzle %84, xzz
    %xzz:ptr<function, vec3<f32>, read_write> = var, %85
    %87:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %88:vec3<f32> = load %87
    %89:vec3<f32> = swizzle %88, yxx
    %yxx:ptr<function, vec3<f32>, read_write> = var, %89
    %91:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %92:vec3<f32> = load %91
    %93:vec3<f32> = swizzle %92, yxy
    %yxy:ptr<function, vec3<f32>, read_write> = var, %93
    %95:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %96:vec3<f32> = load %95
    %97:vec3<f32> = swizzle %96, yxz
    %yxz:ptr<function, vec3<f32>, read_write> = var, %97
    %99:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %100:vec3<f32> = load %99
    %101:vec3<f32> = swizzle %100, yyx
    %yyx:ptr<function, vec3<f32>, read_write> = var, %101
    %103:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %104:vec3<f32> = load %103
    %105:vec3<f32> = swizzle %104, yyy
    %yyy:ptr<function, vec3<f32>, read_write> = var, %105
    %107:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %108:vec3<f32> = load %107
    %109:vec3<f32> = swizzle %108, yyz
    %yyz:ptr<function, vec3<f32>, read_write> = var, %109
    %111:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %112:vec3<f32> = load %111
    %113:vec3<f32> = swizzle %112, yzx
    %yzx:ptr<function, vec3<f32>, read_write> = var, %113
    %115:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %116:vec3<f32> = load %115
    %117:vec3<f32> = swizzle %116, yzy
    %yzy:ptr<function, vec3<f32>, read_write> = var, %117
    %119:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %120:vec3<f32> = load %119
    %121:vec3<f32> = swizzle %120, yzz
    %yzz:ptr<function, vec3<f32>, read_write> = var, %121
    %123:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %124:vec3<f32> = load %123
    %125:vec3<f32> = swizzle %124, zxx
    %zxx:ptr<function, vec3<f32>, read_write> = var, %125
    %127:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %128:vec3<f32> = load %127
    %129:vec3<f32> = swizzle %128, zxy
    %zxy:ptr<function, vec3<f32>, read_write> = var, %129
    %131:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %132:vec3<f32> = load %131
    %133:vec3<f32> = swizzle %132, zxz
    %zxz:ptr<function, vec3<f32>, read_write> = var, %133
    %135:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %136:vec3<f32> = load %135
    %137:vec3<f32> = swizzle %136, zyx
    %zyx:ptr<function, vec3<f32>, read_write> = var, %137
    %139:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %140:vec3<f32> = load %139
    %141:vec3<f32> = swizzle %140, zyy
    %zyy:ptr<function, vec3<f32>, read_write> = var, %141
    %143:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %144:vec3<f32> = load %143
    %145:vec3<f32> = swizzle %144, zyz
    %zyz:ptr<function, vec3<f32>, read_write> = var, %145
    %147:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %148:vec3<f32> = load %147
    %149:vec3<f32> = swizzle %148, zzx
    %zzx:ptr<function, vec3<f32>, read_write> = var, %149
    %151:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %152:vec3<f32> = load %151
    %153:vec3<f32> = swizzle %152, zzy
    %zzy:ptr<function, vec3<f32>, read_write> = var, %153
    %155:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %156:vec3<f32> = load %155
    %157:vec3<f32> = swizzle %156, zzz
    %zzz:ptr<function, vec3<f32>, read_write> = var, %157
    %159:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %160:vec3<f32> = load %159
    %161:vec4<f32> = swizzle %160, xxxx
    %xxxx:ptr<function, vec4<f32>, read_write> = var, %161
    %163:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %164:vec3<f32> = load %163
    %165:vec4<f32> = swizzle %164, xxxy
    %xxxy:ptr<function, vec4<f32>, read_write> = var, %165
    %167:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %168:vec3<f32> = load %167
    %169:vec4<f32> = swizzle %168, xxxz
    %xxxz:ptr<function, vec4<f32>, read_write> = var, %169
    %171:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %172:vec3<f32> = load %171
    %173:vec4<f32> = swizzle %172, xxyx
    %xxyx:ptr<function, vec4<f32>, read_write> = var, %173
    %175:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %176:vec3<f32> = load %175
    %177:vec4<f32> = swizzle %176, xxyy
    %xxyy:ptr<function, vec4<f32>, read_write> = var, %177
    %179:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %180:vec3<f32> = load %179
    %181:vec4<f32> = swizzle %180, xxyz
    %xxyz:ptr<function, vec4<f32>, read_write> = var, %181
    %183:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %184:vec3<f32> = load %183
    %185:vec4<f32> = swizzle %184, xxzx
    %xxzx:ptr<function, vec4<f32>, read_write> = var, %185
    %187:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %188:vec3<f32> = load %187
    %189:vec4<f32> = swizzle %188, xxzy
    %xxzy:ptr<function, vec4<f32>, read_write> = var, %189
    %191:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %192:vec3<f32> = load %191
    %193:vec4<f32> = swizzle %192, xxzz
    %xxzz:ptr<function, vec4<f32>, read_write> = var, %193
    %195:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %196:vec3<f32> = load %195
    %197:vec4<f32> = swizzle %196, xyxx
    %xyxx:ptr<function, vec4<f32>, read_write> = var, %197
    %199:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %200:vec3<f32> = load %199
    %201:vec4<f32> = swizzle %200, xyxy
    %xyxy:ptr<function, vec4<f32>, read_write> = var, %201
    %203:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %204:vec3<f32> = load %203
    %205:vec4<f32> = swizzle %204, xyxz
    %xyxz:ptr<function, vec4<f32>, read_write> = var, %205
    %207:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %208:vec3<f32> = load %207
    %209:vec4<f32> = swizzle %208, xyyx
    %xyyx:ptr<function, vec4<f32>, read_write> = var, %209
    %211:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %212:vec3<f32> = load %211
    %213:vec4<f32> = swizzle %212, xyyy
    %xyyy:ptr<function, vec4<f32>, read_write> = var, %213
    %215:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %216:vec3<f32> = load %215
    %217:vec4<f32> = swizzle %216, xyyz
    %xyyz:ptr<function, vec4<f32>, read_write> = var, %217
    %219:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %220:vec3<f32> = load %219
    %221:vec4<f32> = swizzle %220, xyzx
    %xyzx:ptr<function, vec4<f32>, read_write> = var, %221
    %223:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %224:vec3<f32> = load %223
    %225:vec4<f32> = swizzle %224, xyzy
    %xyzy:ptr<function, vec4<f32>, read_write> = var, %225
    %227:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %228:vec3<f32> = load %227
    %229:vec4<f32> = swizzle %228, xyzz
    %xyzz:ptr<function, vec4<f32>, read_write> = var, %229
    %231:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %232:vec3<f32> = load %231
    %233:vec4<f32> = swizzle %232, xzxx
    %xzxx:ptr<function, vec4<f32>, read_write> = var, %233
    %235:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %236:vec3<f32> = load %235
    %237:vec4<f32> = swizzle %236, xzxy
    %xzxy:ptr<function, vec4<f32>, read_write> = var, %237
    %239:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %240:vec3<f32> = load %239
    %241:vec4<f32> = swizzle %240, xzxz
    %xzxz:ptr<function, vec4<f32>, read_write> = var, %241
    %243:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %244:vec3<f32> = load %243
    %245:vec4<f32> = swizzle %244, xzyx
    %xzyx:ptr<function, vec4<f32>, read_write> = var, %245
    %247:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %248:vec3<f32> = load %247
    %249:vec4<f32> = swizzle %248, xzyy
    %xzyy:ptr<function, vec4<f32>, read_write> = var, %249
    %251:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %252:vec3<f32> = load %251
    %253:vec4<f32> = swizzle %252, xzyz
    %xzyz:ptr<function, vec4<f32>, read_write> = var, %253
    %255:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %256:vec3<f32> = load %255
    %257:vec4<f32> = swizzle %256, xzzx
    %xzzx:ptr<function, vec4<f32>, read_write> = var, %257
    %259:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %260:vec3<f32> = load %259
    %261:vec4<f32> = swizzle %260, xzzy
    %xzzy:ptr<function, vec4<f32>, read_write> = var, %261
    %263:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %264:vec3<f32> = load %263
    %265:vec4<f32> = swizzle %264, xzzz
    %xzzz:ptr<function, vec4<f32>, read_write> = var, %265
    %267:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %268:vec3<f32> = load %267
    %269:vec4<f32> = swizzle %268, yxxx
    %yxxx:ptr<function, vec4<f32>, read_write> = var, %269
    %271:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %272:vec3<f32> = load %271
    %273:vec4<f32> = swizzle %272, yxxy
    %yxxy:ptr<function, vec4<f32>, read_write> = var, %273
    %275:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %276:vec3<f32> = load %275
    %277:vec4<f32> = swizzle %276, yxxz
    %yxxz:ptr<function, vec4<f32>, read_write> = var, %277
    %279:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %280:vec3<f32> = load %279
    %281:vec4<f32> = swizzle %280, yxyx
    %yxyx:ptr<function, vec4<f32>, read_write> = var, %281
    %283:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %284:vec3<f32> = load %283
    %285:vec4<f32> = swizzle %284, yxyy
    %yxyy:ptr<function, vec4<f32>, read_write> = var, %285
    %287:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %288:vec3<f32> = load %287
    %289:vec4<f32> = swizzle %288, yxyz
    %yxyz:ptr<function, vec4<f32>, read_write> = var, %289
    %291:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %292:vec3<f32> = load %291
    %293:vec4<f32> = swizzle %292, yxzx
    %yxzx:ptr<function, vec4<f32>, read_write> = var, %293
    %295:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %296:vec3<f32> = load %295
    %297:vec4<f32> = swizzle %296, yxzy
    %yxzy:ptr<function, vec4<f32>, read_write> = var, %297
    %299:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %300:vec3<f32> = load %299
    %301:vec4<f32> = swizzle %300, yxzz
    %yxzz:ptr<function, vec4<f32>, read_write> = var, %301
    %303:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %304:vec3<f32> = load %303
    %305:vec4<f32> = swizzle %304, yyxx
    %yyxx:ptr<function, vec4<f32>, read_write> = var, %305
    %307:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %308:vec3<f32> = load %307
    %309:vec4<f32> = swizzle %308, yyxy
    %yyxy:ptr<function, vec4<f32>, read_write> = var, %309
    %311:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %312:vec3<f32> = load %311
    %313:vec4<f32> = swizzle %312, yyxz
    %yyxz:ptr<function, vec4<f32>, read_write> = var, %313
    %315:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %316:vec3<f32> = load %315
    %317:vec4<f32> = swizzle %316, yyyx
    %yyyx:ptr<function, vec4<f32>, read_write> = var, %317
    %319:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %320:vec3<f32> = load %319
    %321:vec4<f32> = swizzle %320, yyyy
    %yyyy:ptr<function, vec4<f32>, read_write> = var, %321
    %323:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %324:vec3<f32> = load %323
    %325:vec4<f32> = swizzle %324, yyyz
    %yyyz:ptr<function, vec4<f32>, read_write> = var, %325
    %327:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %328:vec3<f32> = load %327
    %329:vec4<f32> = swizzle %328, yyzx
    %yyzx:ptr<function, vec4<f32>, read_write> = var, %329
    %331:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %332:vec3<f32> = load %331
    %333:vec4<f32> = swizzle %332, yyzy
    %yyzy:ptr<function, vec4<f32>, read_write> = var, %333
    %335:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %336:vec3<f32> = load %335
    %337:vec4<f32> = swizzle %336, yyzz
    %yyzz:ptr<function, vec4<f32>, read_write> = var, %337
    %339:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %340:vec3<f32> = load %339
    %341:vec4<f32> = swizzle %340, yzxx
    %yzxx:ptr<function, vec4<f32>, read_write> = var, %341
    %343:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %344:vec3<f32> = load %343
    %345:vec4<f32> = swizzle %344, yzxy
    %yzxy:ptr<function, vec4<f32>, read_write> = var, %345
    %347:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %348:vec3<f32> = load %347
    %349:vec4<f32> = swizzle %348, yzxz
    %yzxz:ptr<function, vec4<f32>, read_write> = var, %349
    %351:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %352:vec3<f32> = load %351
    %353:vec4<f32> = swizzle %352, yzyx
    %yzyx:ptr<function, vec4<f32>, read_write> = var, %353
    %355:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %356:vec3<f32> = load %355
    %357:vec4<f32> = swizzle %356, yzyy
    %yzyy:ptr<function, vec4<f32>, read_write> = var, %357
    %359:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %360:vec3<f32> = load %359
    %361:vec4<f32> = swizzle %360, yzyz
    %yzyz:ptr<function, vec4<f32>, read_write> = var, %361
    %363:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %364:vec3<f32> = load %363
    %365:vec4<f32> = swizzle %364, yzzx
    %yzzx:ptr<function, vec4<f32>, read_write> = var, %365
    %367:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %368:vec3<f32> = load %367
    %369:vec4<f32> = swizzle %368, yzzy
    %yzzy:ptr<function, vec4<f32>, read_write> = var, %369
    %371:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %372:vec3<f32> = load %371
    %373:vec4<f32> = swizzle %372, yzzz
    %yzzz:ptr<function, vec4<f32>, read_write> = var, %373
    %375:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %376:vec3<f32> = load %375
    %377:vec4<f32> = swizzle %376, zxxx
    %zxxx:ptr<function, vec4<f32>, read_write> = var, %377
    %379:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %380:vec3<f32> = load %379
    %381:vec4<f32> = swizzle %380, zxxy
    %zxxy:ptr<function, vec4<f32>, read_write> = var, %381
    %383:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %384:vec3<f32> = load %383
    %385:vec4<f32> = swizzle %384, zxxz
    %zxxz:ptr<function, vec4<f32>, read_write> = var, %385
    %387:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %388:vec3<f32> = load %387
    %389:vec4<f32> = swizzle %388, zxyx
    %zxyx:ptr<function, vec4<f32>, read_write> = var, %389
    %391:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %392:vec3<f32> = load %391
    %393:vec4<f32> = swizzle %392, zxyy
    %zxyy:ptr<function, vec4<f32>, read_write> = var, %393
    %395:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %396:vec3<f32> = load %395
    %397:vec4<f32> = swizzle %396, zxyz
    %zxyz:ptr<function, vec4<f32>, read_write> = var, %397
    %399:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %400:vec3<f32> = load %399
    %401:vec4<f32> = swizzle %400, zxzx
    %zxzx:ptr<function, vec4<f32>, read_write> = var, %401
    %403:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %404:vec3<f32> = load %403
    %405:vec4<f32> = swizzle %404, zxzy
    %zxzy:ptr<function, vec4<f32>, read_write> = var, %405
    %407:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %408:vec3<f32> = load %407
    %409:vec4<f32> = swizzle %408, zxzz
    %zxzz:ptr<function, vec4<f32>, read_write> = var, %409
    %411:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %412:vec3<f32> = load %411
    %413:vec4<f32> = swizzle %412, zyxx
    %zyxx:ptr<function, vec4<f32>, read_write> = var, %413
    %415:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %416:vec3<f32> = load %415
    %417:vec4<f32> = swizzle %416, zyxy
    %zyxy:ptr<function, vec4<f32>, read_write> = var, %417
    %419:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %420:vec3<f32> = load %419
    %421:vec4<f32> = swizzle %420, zyxz
    %zyxz:ptr<function, vec4<f32>, read_write> = var, %421
    %423:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %424:vec3<f32> = load %423
    %425:vec4<f32> = swizzle %424, zyyx
    %zyyx:ptr<function, vec4<f32>, read_write> = var, %425
    %427:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %428:vec3<f32> = load %427
    %429:vec4<f32> = swizzle %428, zyyy
    %zyyy:ptr<function, vec4<f32>, read_write> = var, %429
    %431:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %432:vec3<f32> = load %431
    %433:vec4<f32> = swizzle %432, zyyz
    %zyyz:ptr<function, vec4<f32>, read_write> = var, %433
    %435:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %436:vec3<f32> = load %435
    %437:vec4<f32> = swizzle %436, zyzx
    %zyzx:ptr<function, vec4<f32>, read_write> = var, %437
    %439:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %440:vec3<f32> = load %439
    %441:vec4<f32> = swizzle %440, zyzy
    %zyzy:ptr<function, vec4<f32>, read_write> = var, %441
    %443:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %444:vec3<f32> = load %443
    %445:vec4<f32> = swizzle %444, zyzz
    %zyzz:ptr<function, vec4<f32>, read_write> = var, %445
    %447:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %448:vec3<f32> = load %447
    %449:vec4<f32> = swizzle %448, zzxx
    %zzxx:ptr<function, vec4<f32>, read_write> = var, %449
    %451:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %452:vec3<f32> = load %451
    %453:vec4<f32> = swizzle %452, zzxy
    %zzxy:ptr<function, vec4<f32>, read_write> = var, %453
    %455:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %456:vec3<f32> = load %455
    %457:vec4<f32> = swizzle %456, zzxz
    %zzxz:ptr<function, vec4<f32>, read_write> = var, %457
    %459:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %460:vec3<f32> = load %459
    %461:vec4<f32> = swizzle %460, zzyx
    %zzyx:ptr<function, vec4<f32>, read_write> = var, %461
    %463:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %464:vec3<f32> = load %463
    %465:vec4<f32> = swizzle %464, zzyy
    %zzyy:ptr<function, vec4<f32>, read_write> = var, %465
    %467:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %468:vec3<f32> = load %467
    %469:vec4<f32> = swizzle %468, zzyz
    %zzyz:ptr<function, vec4<f32>, read_write> = var, %469
    %471:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %472:vec3<f32> = load %471
    %473:vec4<f32> = swizzle %472, zzzx
    %zzzx:ptr<function, vec4<f32>, read_write> = var, %473
    %475:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %476:vec3<f32> = load %475
    %477:vec4<f32> = swizzle %476, zzzy
    %zzzy:ptr<function, vec4<f32>, read_write> = var, %477
    %479:ptr<uniform, vec3<f32>, read> = access %U, 0u
    %480:vec3<f32> = load %479
    %481:vec4<f32> = swizzle %480, zzzz
    %zzzz:ptr<function, vec4<f32>, read_write> = var, %481
    ret
  }
}

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.  *
********************************************************************