test/tint/vk-gl-cts/graphicsfuzz/spv-stable-maze-flatten-copy-composite/2.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_295:ptr<function, bool, read_write> = var
        %x_335:ptr<function, bool, read_write> = var
        %x_348:ptr<function, bool, read_write> = var
        %x_387:ptr<function, bool, read_write> = var
        %x_400: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_296_phi:ptr<function, bool, read_write> = var
        %x_336_phi:ptr<function, bool, read_write> = var
        %x_349_phi:ptr<function, bool, read_write> = var
        %x_388_phi:ptr<function, bool, read_write> = var
        %x_401_phi:ptr<function, bool, read_write> = var
        %155:i32 = load %directions
        %x_170:i32 = let %155
        %157:bool = eq %x_170, 0i
        if %157 [t: $B17, f: $B18] {  # if_10
          $B17: {  # true
            store %canwalk, false
            store %i, 0i
            loop [b: $B19, c: $B20] {  # loop_3
              $B19: {  # body
                %158:i32 = load %i
                %x_179:i32 = let %158
                %160:bool = lt %x_179, 8i
                if %160 [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
                    %161:i32 = load %j
                    %x_186:i32 = let %161
                    %163:bool = lt %x_186, 8i
                    if %163 [t: $B25, f: $B26] {  # if_12
                      $B25: {  # true
                        exit_if  # if_12
                      }
                      $B26: {  # false
                        exit_loop  # loop_4
                      }
                    }
                    %164:i32 = load %j
                    %x_189:i32 = let %164
                    %166:i32 = load %i
                    %x_191:i32 = let %166
                    %168:i32 = mul %x_189, 2i
                    %169:i32 = mul %x_191, 2i
                    %170:i32 = mul %169, 16i
                    %171:i32 = add %168, %170
                    %172:ptr<private, i32, read_write> = access %map, %171
                    %173:i32 = load %172
                    %x_196:i32 = let %173
                    %175:bool = eq %x_196, 0i
                    if %175 [t: $B27] {  # if_13
                      $B27: {  # true
                        %176:i32 = load %j
                        %x_200:i32 = let %176
                        %178:i32 = mul %x_200, 2i
                        store_vector_element %p, 0u, %178
                        %179:i32 = load %i
                        %x_203:i32 = let %179
                        %181:i32 = mul %x_203, 2i
                        store_vector_element %p, 1u, %181
                        store %canwalk, true
                        exit_if  # if_13
                      }
                    }
                    continue  # -> $B24
                  }
                  $B24: {  # continuing
                    %182:i32 = load %j
                    %x_206:i32 = let %182
                    %184:i32 = add %x_206, 1i
                    store %j, %184
                    next_iteration  # -> $B23
                  }
                }
                continue  # -> $B20
              }
              $B20: {  # continuing
                %185:i32 = load %i
                %x_208:i32 = let %185
                %187:i32 = add %x_208, 1i
                store %i, %187
                next_iteration  # -> $B19
              }
            }
            %188:i32 = load_vector_element %p, 0u
            %x_211:i32 = let %188
            %190:i32 = load_vector_element %p, 1u
            %x_213:i32 = let %190
            %192:i32 = mul %x_213, 16i
            %193:i32 = add %x_211, %192
            %194:ptr<private, i32, read_write> = access %map, %193
            store %194, 1i
            exit_if  # if_10
          }
          $B18: {  # false
            %195:i32 = load %v
            %x_217:i32 = let %195
            %197:i32 = load %directions
            %x_218:i32 = let %197
            %199:i32 = call %tint_mod_i32, %x_217, %x_218
            store %d, %199
            %201:i32 = load %directions
            %x_220:i32 = let %201
            %203:i32 = load %v
            %x_221:i32 = let %203
            %205:i32 = add %x_221, %x_220
            store %v, %205
            %206:i32 = load %d
            %x_223:i32 = let %206
            %208:bool = gte %x_223, 0i
            %x_224:bool = let %208
            store %x_230_phi, %x_224
            if %x_224 [t: $B28] {  # if_14
              $B28: {  # true
                %210:i32 = load_vector_element %p, 0u
                %x_228:i32 = let %210
                %212:bool = gt %x_228, 0i
                store %x_229, %212
                %213:bool = load %x_229
                store %x_230_phi, %213
                exit_if  # if_14
              }
            }
            %214:bool = load %x_230_phi
            %x_230:bool = let %214
            store %x_243_phi, %x_230
            if %x_230 [t: $B29] {  # if_15
              $B29: {  # true
                %216:i32 = load_vector_element %p, 0u
                %x_234:i32 = let %216
                %218:i32 = load_vector_element %p, 1u
                %x_237:i32 = let %218
                %220:i32 = sub %x_234, 2i
                %221:i32 = mul %x_237, 16i
                %222:i32 = add %220, %221
                %223:ptr<private, i32, read_write> = access %map, %222
                %224:i32 = load %223
                %x_241:i32 = let %224
                %226:bool = eq %x_241, 0i
                store %x_242, %226
                %227:bool = load %x_242
                store %x_243_phi, %227
                exit_if  # if_15
              }
            }
            %228:bool = load %x_243_phi
            %x_243:bool = let %228
            if %x_243 [t: $B30] {  # if_16
              $B30: {  # true
                %230:i32 = load %d
                %x_246:i32 = let %230
                %232:i32 = sub %x_246, 1i
                store %d, %232
                %233:i32 = load_vector_element %p, 0u
                %x_249:i32 = let %233
                %235:i32 = load_vector_element %p, 1u
                %x_251:i32 = let %235
                %237:i32 = mul %x_251, 16i
                %238:i32 = add %x_249, %237
                %239:ptr<private, i32, read_write> = access %map, %238
                store %239, 1i
                %240:i32 = load_vector_element %p, 0u
                %x_256:i32 = let %240
                %242:i32 = load_vector_element %p, 1u
                %x_259:i32 = let %242
                %244:i32 = sub %x_256, 1i
                %245:i32 = mul %x_259, 16i
                %246:i32 = add %244, %245
                %247:ptr<private, i32, read_write> = access %map, %246
                store %247, 1i
                %248:i32 = load_vector_element %p, 0u
                %x_264:i32 = let %248
                %250:i32 = load_vector_element %p, 1u
                %x_267:i32 = let %250
                %252:i32 = sub %x_264, 2i
                %253:i32 = mul %x_267, 16i
                %254:i32 = add %252, %253
                %255:ptr<private, i32, read_write> = access %map, %254
                store %255, 1i
                %256:i32 = load_vector_element %p, 0u
                %x_272:i32 = let %256
                %258:i32 = sub %x_272, 2i
                store_vector_element %p, 0u, %258
                exit_if  # if_16
              }
            }
            %259:i32 = load %d
            %x_275:i32 = let %259
            %261:bool = gte %x_275, 0i
            %x_276:bool = let %261
            store %x_282_phi, %x_276
            if %x_276 [t: $B31] {  # if_17
              $B31: {  # true
                %263:i32 = load_vector_element %p, 1u
                %x_280:i32 = let %263
                %265:bool = gt %x_280, 0i
                store %x_281, %265
                %266:bool = load %x_281
                store %x_282_phi, %266
                exit_if  # if_17
              }
            }
            %267:bool = load %x_282_phi
            %x_282:bool = let %267
            store %x_296_phi, %x_282
            if %x_282 [t: $B32] {  # if_18
              $B32: {  # true
                %269:i32 = load_vector_element %p, 0u
                %x_286:i32 = let %269
                %271:i32 = load_vector_element %p, 1u
                %x_288:i32 = let %271
                %273:array<i32, 256> = load %map
                %x_291:array<i32, 256> = let %273
                store %map, array<i32, 256>(0i)
                store %map, %x_291
                %275:i32 = sub %x_288, 2i
                %276:i32 = mul %275, 16i
                %277:i32 = add %x_286, %276
                %278:ptr<private, i32, read_write> = access %map, %277
                %279:i32 = load %278
                %x_294:i32 = let %279
                %281:bool = eq %x_294, 0i
                store %x_295, %281
                %282:bool = load %x_295
                store %x_296_phi, %282
                exit_if  # if_18
              }
            }
            %283:bool = load %x_296_phi
            %x_296:bool = let %283
            if %x_296 [t: $B33] {  # if_19
              $B33: {  # true
                %285:i32 = load %d
                %x_299:i32 = let %285
                %287:i32 = sub %x_299, 1i
                store %d, %287
                %288:i32 = load_vector_element %p, 0u
                %x_302:i32 = let %288
                %290:i32 = load_vector_element %p, 1u
                %x_304:i32 = let %290
                %292:i32 = mul %x_304, 16i
                %293:i32 = add %x_302, %292
                %294:ptr<private, i32, read_write> = access %map, %293
                store %294, 1i
                %295:i32 = load_vector_element %p, 0u
                %x_309:i32 = let %295
                %297:i32 = load_vector_element %p, 1u
                %x_311:i32 = let %297
                %299:i32 = sub %x_311, 1i
                %300:i32 = mul %299, 16i
                %301:i32 = add %x_309, %300
                %302:ptr<private, i32, read_write> = access %map, %301
                store %302, 1i
                %303:i32 = load_vector_element %p, 0u
                %x_317:i32 = let %303
                %305:i32 = load_vector_element %p, 1u
                %x_319:i32 = let %305
                %307:array<i32, 256> = load %map
                %x_321:array<i32, 256> = let %307
                store %map, array<i32, 256>(0i)
                store %map, %x_321
                %309:i32 = sub %x_319, 2i
                %310:i32 = mul %309, 16i
                %311:i32 = add %x_317, %310
                %312:ptr<private, i32, read_write> = access %map, %311
                store %312, 1i
                %313:i32 = load_vector_element %p, 1u
                %x_326:i32 = let %313
                %315:i32 = sub %x_326, 2i
                store_vector_element %p, 1u, %315
                exit_if  # if_19
              }
            }
            %316:i32 = load %d
            %x_329:i32 = let %316
            %318:bool = gte %x_329, 0i
            %x_330:bool = let %318
            store %x_336_phi, %x_330
            if %x_330 [t: $B34] {  # if_20
              $B34: {  # true
                %320:i32 = load_vector_element %p, 0u
                %x_334:i32 = let %320
                %322:bool = lt %x_334, 14i
                store %x_335, %322
                %323:bool = load %x_335
                store %x_336_phi, %323
                exit_if  # if_20
              }
            }
            %324:bool = load %x_336_phi
            %x_336:bool = let %324
            store %x_349_phi, %x_336
            if %x_336 [t: $B35] {  # if_21
              $B35: {  # true
                %326:i32 = load_vector_element %p, 0u
                %x_340:i32 = let %326
                %328:i32 = load_vector_element %p, 1u
                %x_343:i32 = let %328
                %330:i32 = add %x_340, 2i
                %331:i32 = mul %x_343, 16i
                %332:i32 = add %330, %331
                %333:ptr<private, i32, read_write> = access %map, %332
                %334:i32 = load %333
                %x_347:i32 = let %334
                %336:bool = eq %x_347, 0i
                store %x_348, %336
                %337:bool = load %x_348
                store %x_349_phi, %337
                exit_if  # if_21
              }
            }
            %338:bool = load %x_349_phi
            %x_349:bool = let %338
            if %x_349 [t: $B36] {  # if_22
              $B36: {  # true
                %340:i32 = load %d
                %x_352:i32 = let %340
                %342:i32 = sub %x_352, 1i
                store %d, %342
                %343:i32 = load_vector_element %p, 0u
                %x_355:i32 = let %343
                %345:i32 = load_vector_element %p, 1u
                %x_357:i32 = let %345
                %347:i32 = mul %x_357, 16i
                %348:i32 = add %x_355, %347
                %349:ptr<private, i32, read_write> = access %map, %348
                store %349, 1i
                %350:i32 = load_vector_element %p, 0u
                %x_362:i32 = let %350
                %352:i32 = load_vector_element %p, 1u
                %x_365:i32 = let %352
                %354:i32 = add %x_362, 1i
                %355:i32 = mul %x_365, 16i
                %356:i32 = add %354, %355
                %357:ptr<private, i32, read_write> = access %map, %356
                store %357, 1i
                %358:i32 = load_vector_element %p, 0u
                %x_370:i32 = let %358
                %360:i32 = load_vector_element %p, 1u
                %x_373:i32 = let %360
                %362:i32 = add %x_370, 2i
                %363:i32 = mul %x_373, 16i
                %364:i32 = add %362, %363
                %365:ptr<private, i32, read_write> = access %map, %364
                store %365, 1i
                %366:i32 = load_vector_element %p, 0u
                %x_378:i32 = let %366
                %368:i32 = add %x_378, 2i
                store_vector_element %p, 0u, %368
                exit_if  # if_22
              }
            }
            %369:i32 = load %d
            %x_381:i32 = let %369
            %371:bool = gte %x_381, 0i
            %x_382:bool = let %371
            store %x_388_phi, %x_382
            if %x_382 [t: $B37] {  # if_23
              $B37: {  # true
                %373:i32 = load_vector_element %p, 1u
                %x_386:i32 = let %373
                %375:bool = lt %x_386, 14i
                store %x_387, %375
                %376:bool = load %x_387
                store %x_388_phi, %376
                exit_if  # if_23
              }
            }
            %377:bool = load %x_388_phi
            %x_388:bool = let %377
            store %x_401_phi, %x_388
            if %x_388 [t: $B38] {  # if_24
              $B38: {  # true
                %379:i32 = load_vector_element %p, 0u
                %x_392:i32 = let %379
                %381:i32 = load_vector_element %p, 1u
                %x_394:i32 = let %381
                %383:i32 = add %x_394, 2i
                %384:i32 = mul %383, 16i
                %385:i32 = add %x_392, %384
                %386:ptr<private, i32, read_write> = access %map, %385
                %387:i32 = load %386
                %x_399:i32 = let %387
                %389:bool = eq %x_399, 0i
                store %x_400, %389
                %390:bool = load %x_400
                store %x_401_phi, %390
                exit_if  # if_24
              }
            }
            %391:bool = load %x_401_phi
            %x_401:bool = let %391
            if %x_401 [t: $B39] {  # if_25
              $B39: {  # true
                %393:i32 = load %d
                %x_404:i32 = let %393
                %395:i32 = sub %x_404, 1i
                store %d, %395
                %396:i32 = load_vector_element %p, 0u
                %x_407:i32 = let %396
                %398:i32 = load_vector_element %p, 1u
                %x_409:i32 = let %398
                %400:i32 = mul %x_409, 16i
                %401:i32 = add %x_407, %400
                %402:ptr<private, i32, read_write> = access %map, %401
                store %402, 1i
                %403:i32 = load_vector_element %p, 0u
                %x_414:i32 = let %403
                %405:i32 = load_vector_element %p, 1u
                %x_416:i32 = let %405
                %407:i32 = add %x_416, 1i
                %408:i32 = mul %407, 16i
                %409:i32 = add %x_414, %408
                %410:ptr<private, i32, read_write> = access %map, %409
                store %410, 1i
                %411:i32 = load_vector_element %p, 0u
                %x_422:i32 = let %411
                %413:i32 = load_vector_element %p, 1u
                %x_424:i32 = let %413
                %415:i32 = add %x_424, 2i
                %416:i32 = mul %415, 16i
                %417:i32 = add %x_422, %416
                %418:ptr<private, i32, read_write> = access %map, %417
                store %418, 1i
                %419:i32 = load_vector_element %p, 1u
                %x_430:i32 = let %419
                %421:i32 = add %x_430, 2i
                store_vector_element %p, 1u, %421
                exit_if  # if_25
              }
            }
            exit_if  # if_10
          }
        }
        %422:i32 = load_vector_element %ipos, 1u
        %x_434:i32 = let %422
        %424:i32 = load_vector_element %ipos, 0u
        %x_437:i32 = let %424
        %426:i32 = mul %x_434, 16i
        %427:i32 = add %426, %x_437
        %428:ptr<private, i32, read_write> = access %map, %427
        %429:i32 = load %428
        %x_440:i32 = let %429
        %431:bool = eq %x_440, 1i
        if %431 [t: $B40] {  # if_26
          $B40: {  # true
            store %x_GLF_color, vec4<f32>(1.0f)
            ret
          }
        }
        continue  # -> $B8
      }
      $B8: {  # continuing
        %432:bool = load %canwalk
        %x_444:bool = let %432
        %434:bool = eq %x_444, false
        break_if %434  # -> [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 {
  $B41: {
    store %gl_FragCoord, %gl_FragCoord_param
    %437:void = call %main_1
    %438:vec4<f32> = load %x_GLF_color
    %439:main_out = construct %438
    ret %439
  }
}
%tint_mod_i32 = func(%lhs:i32, %rhs:i32):i32 {
  $B42: {
    %442:bool = eq %rhs, 0i
    %443:bool = eq %lhs, -2147483648i
    %444:bool = eq %rhs, -1i
    %445:bool = and %443, %444
    %446:bool = or %442, %445
    %447:i32 = select %rhs, 1i, %446
    %448:i32 = let %447
    %449:i32 = div %lhs, %448
    %450:i32 = mul %449, %448
    %451:i32 = sub %lhs, %450
    ret %451
  }
}
%tint_f32_to_i32 = func(%value:f32):i32 {
  $B43: {
    %453:i32 = convert %value
    %454:bool = gte %value, -2147483648.0f
    %455:i32 = select -2147483648i, %453, %454
    %456:bool = lte %value, 2147483520.0f
    %457:i32 = select 2147483647i, %455, %456
    ret %457
  }
}

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