test/tint/vk-gl-cts/graphicsfuzz/spv-stable-maze-flatten-copy-composite/1.wgsl.expected.ir.msl

SKIP: FAILED

../../src/tint/lang/msl/writer/printer/printer.cc:500 internal compiler error: buf0 = struct @align(8) {
  resolution:vec2<f32> @offset(0)
}

main_out = struct @align(16) {
  x_GLF_color_1:vec4<f32> @offset(0), @location(0)
}

$B1: {  # root
  %gl_FragCoord:ptr<private, vec4<f32>, read_write> = var
  %x_7:ptr<uniform, buf0, read> = var @binding_point(0, 0)
  %map:ptr<private, array<i32, 256>, read_write> = var
  %x_GLF_color:ptr<private, vec4<f32>, read_write> = var
}

%main_1 = func():void {
  $B2: {
    %pos:ptr<function, vec2<f32>, read_write> = var
    %ipos:ptr<function, vec2<i32>, read_write> = var
    %i:ptr<function, i32, read_write> = var
    %p:ptr<function, vec2<i32>, read_write> = var
    %canwalk:ptr<function, bool, read_write> = var
    %v:ptr<function, i32, read_write> = var
    %directions:ptr<function, i32, read_write> = var
    %j:ptr<function, i32, read_write> = var
    %d:ptr<function, i32, read_write> = var
    %15:vec4<f32> = load %gl_FragCoord
    %x_59:vec4<f32> = let %15
    %17:ptr<uniform, vec2<f32>, read> = access %x_7, 0u
    %18:vec2<f32> = load %17
    %x_62:vec2<f32> = let %18
    %20:f32 = access %x_59, 0u
    %21:f32 = access %x_59, 1u
    %22:vec2<f32> = construct %20, %21
    %23:vec2<f32> = div %22, %x_62
    store %pos, %23
    %24:f32 = load_vector_element %pos, 0u
    %x_65:f32 = let %24
    %26:f32 = load_vector_element %pos, 1u
    %x_69:f32 = let %26
    %28:f32 = mul %x_65, 16.0f
    %29:i32 = call %tint_f32_to_i32, %28
    %31:i32 = let %29
    %32:f32 = mul %x_69, 16.0f
    %33:i32 = call %tint_f32_to_i32, %32
    %34:vec2<i32> = construct %31, %33
    store %ipos, %34
    store %i, 0i
    loop [b: $B3, c: $B4] {  # loop_1
      $B3: {  # body
        %35:i32 = load %i
        %x_77:i32 = let %35
        %37:bool = lt %x_77, 256i
        if %37 [t: $B5, f: $B6] {  # if_1
          $B5: {  # true
            exit_if  # if_1
          }
          $B6: {  # false
            exit_loop  # loop_1
          }
        }
        %38:i32 = load %i
        %x_80:i32 = let %38
        %40:ptr<private, i32, read_write> = access %map, %x_80
        store %40, 0i
        continue  # -> $B4
      }
      $B4: {  # continuing
        %41:i32 = load %i
        %x_82:i32 = let %41
        %43:i32 = add %x_82, 1i
        store %i, %43
        next_iteration  # -> $B3
      }
    }
    store %p, vec2<i32>(0i)
    store %canwalk, true
    store %v, 0i
    loop [b: $B7, c: $B8] {  # loop_2
      $B7: {  # body
        %x_104:ptr<function, bool, read_write> = var
        %x_124:ptr<function, bool, read_write> = var
        %x_144:ptr<function, bool, read_write> = var
        %x_164:ptr<function, bool, read_write> = var
        %x_105_phi:ptr<function, bool, read_write> = var
        %x_125_phi:ptr<function, bool, read_write> = var
        %x_145_phi:ptr<function, bool, read_write> = var
        %x_165_phi:ptr<function, bool, read_write> = var
        %52:i32 = load %v
        %x_88:i32 = let %52
        %54:i32 = add %x_88, 1i
        store %v, %54
        store %directions, 0i
        %55:i32 = load_vector_element %p, 0u
        %x_91:i32 = let %55
        %57:bool = gt %x_91, 0i
        %x_92:bool = let %57
        store %x_105_phi, %x_92
        if %x_92 [t: $B9] {  # if_2
          $B9: {  # true
            %59:i32 = load_vector_element %p, 0u
            %x_96:i32 = let %59
            %61:i32 = load_vector_element %p, 1u
            %x_99:i32 = let %61
            %63:i32 = sub %x_96, 2i
            %64:i32 = mul %x_99, 16i
            %65:i32 = add %63, %64
            %66:ptr<private, i32, read_write> = access %map, %65
            %67:i32 = load %66
            %x_103:i32 = let %67
            %69:bool = eq %x_103, 0i
            store %x_104, %69
            %70:bool = load %x_104
            store %x_105_phi, %70
            exit_if  # if_2
          }
        }
        %71:bool = load %x_105_phi
        %x_105:bool = let %71
        if %x_105 [t: $B10] {  # if_3
          $B10: {  # true
            %73:i32 = load %directions
            %x_108:i32 = let %73
            %75:i32 = add %x_108, 1i
            store %directions, %75
            exit_if  # if_3
          }
        }
        %76:i32 = load_vector_element %p, 1u
        %x_111:i32 = let %76
        %78:bool = gt %x_111, 0i
        %x_112:bool = let %78
        store %x_125_phi, %x_112
        if %x_112 [t: $B11] {  # if_4
          $B11: {  # true
            %80:i32 = load_vector_element %p, 0u
            %x_116:i32 = let %80
            %82:i32 = load_vector_element %p, 1u
            %x_118:i32 = let %82
            %84:i32 = sub %x_118, 2i
            %85:i32 = mul %84, 16i
            %86:i32 = add %x_116, %85
            %87:ptr<private, i32, read_write> = access %map, %86
            %88:i32 = load %87
            %x_123:i32 = let %88
            %90:bool = eq %x_123, 0i
            store %x_124, %90
            %91:bool = load %x_124
            store %x_125_phi, %91
            exit_if  # if_4
          }
        }
        %92:bool = load %x_125_phi
        %x_125:bool = let %92
        if %x_125 [t: $B12] {  # if_5
          $B12: {  # true
            %94:i32 = load %directions
            %x_128:i32 = let %94
            %96:i32 = add %x_128, 1i
            store %directions, %96
            exit_if  # if_5
          }
        }
        %97:i32 = load_vector_element %p, 0u
        %x_131:i32 = let %97
        %99:bool = lt %x_131, 14i
        %x_132:bool = let %99
        store %x_145_phi, %x_132
        if %x_132 [t: $B13] {  # if_6
          $B13: {  # true
            %101:i32 = load_vector_element %p, 0u
            %x_136:i32 = let %101
            %103:i32 = load_vector_element %p, 1u
            %x_139:i32 = let %103
            %105:i32 = add %x_136, 2i
            %106:i32 = mul %x_139, 16i
            %107:i32 = add %105, %106
            %108:ptr<private, i32, read_write> = access %map, %107
            %109:i32 = load %108
            %x_143:i32 = let %109
            %111:bool = eq %x_143, 0i
            store %x_144, %111
            %112:bool = load %x_144
            store %x_145_phi, %112
            exit_if  # if_6
          }
        }
        %113:bool = load %x_145_phi
        %x_145:bool = let %113
        if %x_145 [t: $B14] {  # if_7
          $B14: {  # true
            %115:i32 = load %directions
            %x_148:i32 = let %115
            %117:i32 = add %x_148, 1i
            store %directions, %117
            exit_if  # if_7
          }
        }
        %118:i32 = load_vector_element %p, 1u
        %x_151:i32 = let %118
        %120:bool = lt %x_151, 14i
        %x_152:bool = let %120
        store %x_165_phi, %x_152
        if %x_152 [t: $B15] {  # if_8
          $B15: {  # true
            %122:i32 = load_vector_element %p, 0u
            %x_156:i32 = let %122
            %124:i32 = load_vector_element %p, 1u
            %x_158:i32 = let %124
            %126:i32 = add %x_158, 2i
            %127:i32 = mul %126, 16i
            %128:i32 = add %x_156, %127
            %129:ptr<private, i32, read_write> = access %map, %128
            %130:i32 = load %129
            %x_163:i32 = let %130
            %132:bool = eq %x_163, 0i
            store %x_164, %132
            %133:bool = load %x_164
            store %x_165_phi, %133
            exit_if  # if_8
          }
        }
        %134:bool = load %x_165_phi
        %x_165:bool = let %134
        if %x_165 [t: $B16] {  # if_9
          $B16: {  # true
            %136:i32 = load %directions
            %x_168:i32 = let %136
            %138:i32 = add %x_168, 1i
            store %directions, %138
            exit_if  # if_9
          }
        }
        %x_229:ptr<function, bool, read_write> = var
        %x_242:ptr<function, bool, read_write> = var
        %x_281:ptr<function, bool, read_write> = var
        %x_288:ptr<function, i32, read_write> = var
        %x_289:ptr<function, i32, read_write> = var
        %x_295:ptr<function, i32, read_write> = var
        %x_296:ptr<function, i32, read_write> = var
        %x_303:ptr<function, array<i32, 256>, read_write> = var
        %x_304:ptr<function, array<i32, 256>, read_write> = var
        %x_315:ptr<function, i32, read_write> = var
        %x_316:ptr<function, i32, read_write> = var
        %x_359:ptr<function, bool, read_write> = var
        %x_372:ptr<function, bool, read_write> = var
        %x_411:ptr<function, bool, read_write> = var
        %x_424:ptr<function, bool, read_write> = var
        %x_230_phi:ptr<function, bool, read_write> = var
        %x_243_phi:ptr<function, bool, read_write> = var
        %x_282_phi:ptr<function, bool, read_write> = var
        %x_290_phi:ptr<function, i32, read_write> = var
        %x_297_phi:ptr<function, i32, read_write> = var
        %x_305_phi:ptr<function, array<i32, 256>, read_write> = var
        %x_317_phi:ptr<function, i32, read_write> = var
        %x_360_phi:ptr<function, bool, read_write> = var
        %x_373_phi:ptr<function, bool, read_write> = var
        %x_412_phi:ptr<function, bool, read_write> = var
        %x_425_phi:ptr<function, bool, read_write> = var
        %165:i32 = load %directions
        %x_170:i32 = let %165
        %167:bool = eq %x_170, 0i
        if %167 [t: $B17, f: $B18] {  # if_10
          $B17: {  # true
            store %canwalk, false
            store %i, 0i
            loop [b: $B19, c: $B20] {  # loop_3
              $B19: {  # body
                %168:i32 = load %i
                %x_179:i32 = let %168
                %170:bool = lt %x_179, 8i
                if %170 [t: $B21, f: $B22] {  # if_11
                  $B21: {  # true
                    exit_if  # if_11
                  }
                  $B22: {  # false
                    exit_loop  # loop_3
                  }
                }
                store %j, 0i
                loop [b: $B23, c: $B24] {  # loop_4
                  $B23: {  # body
                    %171:i32 = load %j
                    %x_186:i32 = let %171
                    %173:bool = lt %x_186, 8i
                    if %173 [t: $B25, f: $B26] {  # if_12
                      $B25: {  # true
                        exit_if  # if_12
                      }
                      $B26: {  # false
                        exit_loop  # loop_4
                      }
                    }
                    %174:i32 = load %j
                    %x_189:i32 = let %174
                    %176:i32 = load %i
                    %x_191:i32 = let %176
                    %178:i32 = mul %x_189, 2i
                    %179:i32 = mul %x_191, 2i
                    %180:i32 = mul %179, 16i
                    %181:i32 = add %178, %180
                    %182:ptr<private, i32, read_write> = access %map, %181
                    %183:i32 = load %182
                    %x_196:i32 = let %183
                    %185:bool = eq %x_196, 0i
                    if %185 [t: $B27] {  # if_13
                      $B27: {  # true
                        %186:i32 = load %j
                        %x_200:i32 = let %186
                        %188:i32 = mul %x_200, 2i
                        store_vector_element %p, 0u, %188
                        %189:i32 = load %i
                        %x_203:i32 = let %189
                        %191:i32 = mul %x_203, 2i
                        store_vector_element %p, 1u, %191
                        store %canwalk, true
                        exit_if  # if_13
                      }
                    }
                    continue  # -> $B24
                  }
                  $B24: {  # continuing
                    %192:i32 = load %j
                    %x_206:i32 = let %192
                    %194:i32 = add %x_206, 1i
                    store %j, %194
                    next_iteration  # -> $B23
                  }
                }
                continue  # -> $B20
              }
              $B20: {  # continuing
                %195:i32 = load %i
                %x_208:i32 = let %195
                %197:i32 = add %x_208, 1i
                store %i, %197
                next_iteration  # -> $B19
              }
            }
            %198:i32 = load_vector_element %p, 0u
            %x_211:i32 = let %198
            %200:i32 = load_vector_element %p, 1u
            %x_213:i32 = let %200
            %202:i32 = mul %x_213, 16i
            %203:i32 = add %x_211, %202
            %204:ptr<private, i32, read_write> = access %map, %203
            store %204, 1i
            exit_if  # if_10
          }
          $B18: {  # false
            %205:i32 = load %v
            %x_217:i32 = let %205
            %207:i32 = load %directions
            %x_218:i32 = let %207
            %209:i32 = call %tint_mod_i32, %x_217, %x_218
            store %d, %209
            %211:i32 = load %directions
            %x_220:i32 = let %211
            %213:i32 = load %v
            %x_221:i32 = let %213
            %215:i32 = add %x_221, %x_220
            store %v, %215
            %216:i32 = load %d
            %x_223:i32 = let %216
            %218:bool = gte %x_223, 0i
            %x_224:bool = let %218
            store %x_230_phi, %x_224
            if %x_224 [t: $B28] {  # if_14
              $B28: {  # true
                %220:i32 = load_vector_element %p, 0u
                %x_228:i32 = let %220
                %222:bool = gt %x_228, 0i
                store %x_229, %222
                %223:bool = load %x_229
                store %x_230_phi, %223
                exit_if  # if_14
              }
            }
            %224:bool = load %x_230_phi
            %x_230:bool = let %224
            store %x_243_phi, %x_230
            if %x_230 [t: $B29] {  # if_15
              $B29: {  # true
                %226:i32 = load_vector_element %p, 0u
                %x_234:i32 = let %226
                %228:i32 = load_vector_element %p, 1u
                %x_237:i32 = let %228
                %230:i32 = sub %x_234, 2i
                %231:i32 = mul %x_237, 16i
                %232:i32 = add %230, %231
                %233:ptr<private, i32, read_write> = access %map, %232
                %234:i32 = load %233
                %x_241:i32 = let %234
                %236:bool = eq %x_241, 0i
                store %x_242, %236
                %237:bool = load %x_242
                store %x_243_phi, %237
                exit_if  # if_15
              }
            }
            %238:bool = load %x_243_phi
            %x_243:bool = let %238
            if %x_243 [t: $B30] {  # if_16
              $B30: {  # true
                %240:i32 = load %d
                %x_246:i32 = let %240
                %242:i32 = sub %x_246, 1i
                store %d, %242
                %243:i32 = load_vector_element %p, 0u
                %x_249:i32 = let %243
                %245:i32 = load_vector_element %p, 1u
                %x_251:i32 = let %245
                %247:i32 = mul %x_251, 16i
                %248:i32 = add %x_249, %247
                %249:ptr<private, i32, read_write> = access %map, %248
                store %249, 1i
                %250:i32 = load_vector_element %p, 0u
                %x_256:i32 = let %250
                %252:i32 = load_vector_element %p, 1u
                %x_259:i32 = let %252
                %254:i32 = sub %x_256, 1i
                %255:i32 = mul %x_259, 16i
                %256:i32 = add %254, %255
                %257:ptr<private, i32, read_write> = access %map, %256
                store %257, 1i
                %258:i32 = load_vector_element %p, 0u
                %x_264:i32 = let %258
                %260:i32 = load_vector_element %p, 1u
                %x_267:i32 = let %260
                %262:i32 = sub %x_264, 2i
                %263:i32 = mul %x_267, 16i
                %264:i32 = add %262, %263
                %265:ptr<private, i32, read_write> = access %map, %264
                store %265, 1i
                %266:i32 = load_vector_element %p, 0u
                %x_272:i32 = let %266
                %268:i32 = sub %x_272, 2i
                store_vector_element %p, 0u, %268
                exit_if  # if_16
              }
            }
            %269:i32 = load %d
            %x_275:i32 = let %269
            %271:bool = gte %x_275, 0i
            %x_276:bool = let %271
            store %x_282_phi, %x_276
            if %x_276 [t: $B31] {  # if_17
              $B31: {  # true
                %273:i32 = load_vector_element %p, 1u
                %x_280:i32 = let %273
                %275:bool = gt %x_280, 0i
                store %x_281, %275
                %276:bool = load %x_281
                store %x_282_phi, %276
                exit_if  # if_17
              }
            }
            %277:bool = load %x_282_phi
            %x_282:bool = let %277
            if %x_282 [t: $B32, f: $B33] {  # if_18
              $B32: {  # true
                %279:i32 = load_vector_element %p, 0u
                store %x_288, %279
                %280:i32 = load %x_288
                store %x_290_phi, %280
                exit_if  # if_18
              }
              $B33: {  # false
                store %x_289, 0i
                %281:i32 = load %x_289
                store %x_290_phi, %281
                exit_if  # if_18
              }
            }
            %282:i32 = load %x_290_phi
            %x_290:i32 = let %282
            if %x_282 [t: $B34, f: $B35] {  # if_19
              $B34: {  # true
                %284:i32 = load_vector_element %p, 1u
                store %x_295, %284
                %285:i32 = load %x_295
                store %x_297_phi, %285
                exit_if  # if_19
              }
              $B35: {  # false
                store %x_296, 0i
                %286:i32 = load %x_296
                store %x_297_phi, %286
                exit_if  # if_19
              }
            }
            %287:i32 = load %x_297_phi
            %x_297:i32 = let %287
            %289:i32 = sub %x_297, 2i
            %290:i32 = mul %289, 16i
            %x_299:i32 = let %290
            if %x_282 [t: $B36, f: $B37] {  # if_20
              $B36: {  # true
                %292:array<i32, 256> = load %map
                store %x_303, %292
                %293:array<i32, 256> = load %x_303
                store %x_305_phi, %293
                exit_if  # if_20
              }
              $B37: {  # false
                store %x_304, array<i32, 256>(0i)
                %294:array<i32, 256> = load %x_304
                store %x_305_phi, %294
                exit_if  # if_20
              }
            }
            %295:array<i32, 256> = load %x_305_phi
            %x_305:array<i32, 256> = let %295
            if %x_282 [t: $B38] {  # if_21
              $B38: {  # true
                store %map, array<i32, 256>(0i)
                exit_if  # if_21
              }
            }
            if %x_282 [t: $B39] {  # if_22
              $B39: {  # true
                store %map, %x_305
                exit_if  # if_22
              }
            }
            if %x_282 [t: $B40, f: $B41] {  # if_23
              $B40: {  # true
                %297:i32 = add %x_290, %x_299
                %298:ptr<private, i32, read_write> = access %map, %297
                %299:i32 = load %298
                store %x_315, %299
                %300:i32 = load %x_315
                store %x_317_phi, %300
                exit_if  # if_23
              }
              $B41: {  # false
                store %x_316, 0i
                %301:i32 = load %x_316
                store %x_317_phi, %301
                exit_if  # if_23
              }
            }
            %302:i32 = load %x_317_phi
            %x_317:i32 = let %302
            %304:bool = eq %x_317, 0i
            %x_318:bool = let %304
            %306:bool = select %x_282, %x_318, %x_282
            if %306 [t: $B42] {  # if_24
              $B42: {  # true
                %307:i32 = load %d
                %x_323:i32 = let %307
                %309:i32 = sub %x_323, 1i
                store %d, %309
                %310:i32 = load_vector_element %p, 0u
                %x_326:i32 = let %310
                %312:i32 = load_vector_element %p, 1u
                %x_328:i32 = let %312
                %314:i32 = mul %x_328, 16i
                %315:i32 = add %x_326, %314
                %316:ptr<private, i32, read_write> = access %map, %315
                store %316, 1i
                %317:i32 = load_vector_element %p, 0u
                %x_333:i32 = let %317
                %319:i32 = load_vector_element %p, 1u
                %x_335:i32 = let %319
                %321:i32 = sub %x_335, 1i
                %322:i32 = mul %321, 16i
                %323:i32 = add %x_333, %322
                %324:ptr<private, i32, read_write> = access %map, %323
                store %324, 1i
                %325:i32 = load_vector_element %p, 0u
                %x_341:i32 = let %325
                %327:i32 = load_vector_element %p, 1u
                %x_343:i32 = let %327
                %329:array<i32, 256> = load %map
                %x_345:array<i32, 256> = let %329
                store %map, array<i32, 256>(0i)
                store %map, %x_345
                %331:i32 = sub %x_343, 2i
                %332:i32 = mul %331, 16i
                %333:i32 = add %x_341, %332
                %334:ptr<private, i32, read_write> = access %map, %333
                store %334, 1i
                %335:i32 = load_vector_element %p, 1u
                %x_350:i32 = let %335
                %337:i32 = sub %x_350, 2i
                store_vector_element %p, 1u, %337
                exit_if  # if_24
              }
            }
            %338:i32 = load %d
            %x_353:i32 = let %338
            %340:bool = gte %x_353, 0i
            %x_354:bool = let %340
            store %x_360_phi, %x_354
            if %x_354 [t: $B43] {  # if_25
              $B43: {  # true
                %342:i32 = load_vector_element %p, 0u
                %x_358:i32 = let %342
                %344:bool = lt %x_358, 14i
                store %x_359, %344
                %345:bool = load %x_359
                store %x_360_phi, %345
                exit_if  # if_25
              }
            }
            %346:bool = load %x_360_phi
            %x_360:bool = let %346
            store %x_373_phi, %x_360
            if %x_360 [t: $B44] {  # if_26
              $B44: {  # true
                %348:i32 = load_vector_element %p, 0u
                %x_364:i32 = let %348
                %350:i32 = load_vector_element %p, 1u
                %x_367:i32 = let %350
                %352:i32 = add %x_364, 2i
                %353:i32 = mul %x_367, 16i
                %354:i32 = add %352, %353
                %355:ptr<private, i32, read_write> = access %map, %354
                %356:i32 = load %355
                %x_371:i32 = let %356
                %358:bool = eq %x_371, 0i
                store %x_372, %358
                %359:bool = load %x_372
                store %x_373_phi, %359
                exit_if  # if_26
              }
            }
            %360:bool = load %x_373_phi
            %x_373:bool = let %360
            if %x_373 [t: $B45] {  # if_27
              $B45: {  # true
                %362:i32 = load %d
                %x_376:i32 = let %362
                %364:i32 = sub %x_376, 1i
                store %d, %364
                %365:i32 = load_vector_element %p, 0u
                %x_379:i32 = let %365
                %367:i32 = load_vector_element %p, 1u
                %x_381:i32 = let %367
                %369:i32 = mul %x_381, 16i
                %370:i32 = add %x_379, %369
                %371:ptr<private, i32, read_write> = access %map, %370
                store %371, 1i
                %372:i32 = load_vector_element %p, 0u
                %x_386:i32 = let %372
                %374:i32 = load_vector_element %p, 1u
                %x_389:i32 = let %374
                %376:i32 = add %x_386, 1i
                %377:i32 = mul %x_389, 16i
                %378:i32 = add %376, %377
                %379:ptr<private, i32, read_write> = access %map, %378
                store %379, 1i
                %380:i32 = load_vector_element %p, 0u
                %x_394:i32 = let %380
                %382:i32 = load_vector_element %p, 1u
                %x_397:i32 = let %382
                %384:i32 = add %x_394, 2i
                %385:i32 = mul %x_397, 16i
                %386:i32 = add %384, %385
                %387:ptr<private, i32, read_write> = access %map, %386
                store %387, 1i
                %388:i32 = load_vector_element %p, 0u
                %x_402:i32 = let %388
                %390:i32 = add %x_402, 2i
                store_vector_element %p, 0u, %390
                exit_if  # if_27
              }
            }
            %391:i32 = load %d
            %x_405:i32 = let %391
            %393:bool = gte %x_405, 0i
            %x_406:bool = let %393
            store %x_412_phi, %x_406
            if %x_406 [t: $B46] {  # if_28
              $B46: {  # true
                %395:i32 = load_vector_element %p, 1u
                %x_410:i32 = let %395
                %397:bool = lt %x_410, 14i
                store %x_411, %397
                %398:bool = load %x_411
                store %x_412_phi, %398
                exit_if  # if_28
              }
            }
            %399:bool = load %x_412_phi
            %x_412:bool = let %399
            store %x_425_phi, %x_412
            if %x_412 [t: $B47] {  # if_29
              $B47: {  # true
                %401:i32 = load_vector_element %p, 0u
                %x_416:i32 = let %401
                %403:i32 = load_vector_element %p, 1u
                %x_418:i32 = let %403
                %405:i32 = add %x_418, 2i
                %406:i32 = mul %405, 16i
                %407:i32 = add %x_416, %406
                %408:ptr<private, i32, read_write> = access %map, %407
                %409:i32 = load %408
                %x_423:i32 = let %409
                %411:bool = eq %x_423, 0i
                store %x_424, %411
                %412:bool = load %x_424
                store %x_425_phi, %412
                exit_if  # if_29
              }
            }
            %413:bool = load %x_425_phi
            %x_425:bool = let %413
            if %x_425 [t: $B48] {  # if_30
              $B48: {  # true
                %415:i32 = load %d
                %x_428:i32 = let %415
                %417:i32 = sub %x_428, 1i
                store %d, %417
                %418:i32 = load_vector_element %p, 0u
                %x_431:i32 = let %418
                %420:i32 = load_vector_element %p, 1u
                %x_433:i32 = let %420
                %422:i32 = mul %x_433, 16i
                %423:i32 = add %x_431, %422
                %424:ptr<private, i32, read_write> = access %map, %423
                store %424, 1i
                %425:i32 = load_vector_element %p, 0u
                %x_438:i32 = let %425
                %427:i32 = load_vector_element %p, 1u
                %x_440:i32 = let %427
                %429:i32 = add %x_440, 1i
                %430:i32 = mul %429, 16i
                %431:i32 = add %x_438, %430
                %432:ptr<private, i32, read_write> = access %map, %431
                store %432, 1i
                %433:i32 = load_vector_element %p, 0u
                %x_446:i32 = let %433
                %435:i32 = load_vector_element %p, 1u
                %x_448:i32 = let %435
                %437:i32 = add %x_448, 2i
                %438:i32 = mul %437, 16i
                %439:i32 = add %x_446, %438
                %440:ptr<private, i32, read_write> = access %map, %439
                store %440, 1i
                %441:i32 = load_vector_element %p, 1u
                %x_454:i32 = let %441
                %443:i32 = add %x_454, 2i
                store_vector_element %p, 1u, %443
                exit_if  # if_30
              }
            }
            exit_if  # if_10
          }
        }
        %444:i32 = load_vector_element %ipos, 1u
        %x_458:i32 = let %444
        %446:i32 = load_vector_element %ipos, 0u
        %x_461:i32 = let %446
        %448:i32 = mul %x_458, 16i
        %449:i32 = add %448, %x_461
        %450:ptr<private, i32, read_write> = access %map, %449
        %451:i32 = load %450
        %x_464:i32 = let %451
        %453:bool = eq %x_464, 1i
        if %453 [t: $B49] {  # if_31
          $B49: {  # true
            store %x_GLF_color, vec4<f32>(1.0f)
            ret
          }
        }
        continue  # -> $B8
      }
      $B8: {  # continuing
        %454:bool = load %canwalk
        %x_468:bool = let %454
        %456:bool = eq %x_468, false
        break_if %456  # -> [t: exit_loop loop_2, f: $B7]
      }
    }
    store %x_GLF_color, vec4<f32>(0.0f, 0.0f, 0.0f, 1.0f)
    ret
  }
}
%tint_symbol = @fragment func(%gl_FragCoord_param:vec4<f32> [@position]):main_out {
  $B50: {
    store %gl_FragCoord, %gl_FragCoord_param
    %459:void = call %main_1
    %460:vec4<f32> = load %x_GLF_color
    %461:main_out = construct %460
    ret %461
  }
}
%tint_mod_i32 = func(%lhs:i32, %rhs:i32):i32 {
  $B51: {
    %464:bool = eq %rhs, 0i
    %465:bool = eq %lhs, -2147483648i
    %466:bool = eq %rhs, -1i
    %467:bool = and %465, %466
    %468:bool = or %464, %467
    %469:i32 = select %rhs, 1i, %468
    %470:i32 = let %469
    %471:i32 = div %lhs, %470
    %472:i32 = mul %471, %470
    %473:i32 = sub %lhs, %472
    ret %473
  }
}
%tint_f32_to_i32 = func(%value:f32):i32 {
  $B52: {
    %475:i32 = convert %value
    %476:bool = gte %value, -2147483648.0f
    %477:i32 = select -2147483648i, %475, %476
    %478:bool = lte %value, 2147483520.0f
    %479:i32 = select 2147483647i, %477, %478
    ret %479
  }
}

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